1 /* Support for the generic parts of PE/PEI; the common executable parts.
2 Copyright (C) 1995-2023 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,
64 COFF_WITH_peAArch64 or COFF_WITH_peLoongArch64 depending on whether we're
65 compiling for straight PE or PE+. */
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"
89 #elif defined COFF_WITH_peLoongArch64
90 # include "coff/loongarch64.h"
92 # include "coff/i386.h"
98 #include "safe-ctype.h"
100 #if defined COFF_WITH_pep || defined COFF_WITH_pex64 || defined COFF_WITH_peAArch64 || defined COFF_WITH_peLoongArch64
102 # define AOUTSZ PEPAOUTSZ
103 # define PEAOUTHDR PEPAOUTHDR
106 #define HighBitSet(val) ((val) & 0x80000000)
107 #define SetHighBit(val) ((val) | 0x80000000)
108 #define WithoutHighBit(val) ((val) & 0x7fffffff)
111 _bfd_XXi_swap_sym_in (bfd
* abfd
, void * ext1
, void * in1
)
113 SYMENT
*ext
= (SYMENT
*) ext1
;
114 struct internal_syment
*in
= (struct internal_syment
*) in1
;
116 if (ext
->e
.e_name
[0] == 0)
118 in
->_n
._n_n
._n_zeroes
= 0;
119 in
->_n
._n_n
._n_offset
= H_GET_32 (abfd
, ext
->e
.e
.e_offset
);
122 memcpy (in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
124 in
->n_value
= H_GET_32 (abfd
, ext
->e_value
);
125 in
->n_scnum
= (short) H_GET_16 (abfd
, ext
->e_scnum
);
127 if (sizeof (ext
->e_type
) == 2)
128 in
->n_type
= H_GET_16 (abfd
, ext
->e_type
);
130 in
->n_type
= H_GET_32 (abfd
, ext
->e_type
);
132 in
->n_sclass
= H_GET_8 (abfd
, ext
->e_sclass
);
133 in
->n_numaux
= H_GET_8 (abfd
, ext
->e_numaux
);
135 #ifndef STRICT_PE_FORMAT
136 /* This is for Gnu-created DLLs. */
138 /* The section symbols for the .idata$ sections have class 0x68
139 (C_SECTION), which MS documentation indicates is a section
140 symbol. Unfortunately, the value field in the symbol is simply a
141 copy of the .idata section's flags rather than something useful.
142 When these symbols are encountered, change the value to 0 so that
143 they will be handled somewhat correctly in the bfd code. */
144 if (in
->n_sclass
== C_SECTION
)
146 char namebuf
[SYMNMLEN
+ 1];
147 const char *name
= NULL
;
151 /* Create synthetic empty sections as needed. DJ */
152 if (in
->n_scnum
== 0)
156 name
= _bfd_coff_internal_syment_name (abfd
, in
, namebuf
);
159 _bfd_error_handler (_("%pB: unable to find name for empty section"),
161 bfd_set_error (bfd_error_invalid_target
);
165 sec
= bfd_get_section_by_name (abfd
, name
);
167 in
->n_scnum
= sec
->target_index
;
170 if (in
->n_scnum
== 0)
172 int unused_section_number
= 0;
178 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
179 if (unused_section_number
<= sec
->target_index
)
180 unused_section_number
= sec
->target_index
+ 1;
182 name_len
= strlen (name
) + 1;
183 sec_name
= bfd_alloc (abfd
, name_len
);
184 if (sec_name
== NULL
)
186 _bfd_error_handler (_("%pB: out of memory creating name "
187 "for empty section"), abfd
);
190 memcpy (sec_name
, name
, name_len
);
192 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_DATA
| SEC_LOAD
;
193 sec
= bfd_make_section_anyway_with_flags (abfd
, sec_name
, flags
);
196 _bfd_error_handler (_("%pB: unable to create fake empty section"),
205 sec
->rel_filepos
= 0;
206 sec
->reloc_count
= 0;
207 sec
->line_filepos
= 0;
208 sec
->lineno_count
= 0;
209 sec
->userdata
= NULL
;
211 sec
->alignment_power
= 2;
213 sec
->target_index
= unused_section_number
;
215 in
->n_scnum
= unused_section_number
;
217 in
->n_sclass
= C_STAT
;
223 abs_finder (bfd
* abfd ATTRIBUTE_UNUSED
, asection
* sec
, void * data
)
225 bfd_vma abs_val
= * (bfd_vma
*) data
;
227 return (sec
->vma
<= abs_val
) && ((sec
->vma
+ (1ULL << 32)) > abs_val
);
231 _bfd_XXi_swap_sym_out (bfd
* abfd
, void * inp
, void * extp
)
233 struct internal_syment
*in
= (struct internal_syment
*) inp
;
234 SYMENT
*ext
= (SYMENT
*) extp
;
236 if (in
->_n
._n_name
[0] == 0)
238 H_PUT_32 (abfd
, 0, ext
->e
.e
.e_zeroes
);
239 H_PUT_32 (abfd
, in
->_n
._n_n
._n_offset
, ext
->e
.e
.e_offset
);
242 memcpy (ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
244 /* The PE32 and PE32+ formats only use 4 bytes to hold the value of a
245 symbol. This is a problem on 64-bit targets where we can generate
246 absolute symbols with values >= 1^32. We try to work around this
247 problem by finding a section whose base address is sufficient to
248 reduce the absolute value to < 1^32, and then transforming the
249 symbol into a section relative symbol. This of course is a hack. */
250 if (sizeof (in
->n_value
) > 4
251 /* The strange computation of the shift amount is here in order to
252 avoid a compile time warning about the comparison always being
253 false. It does not matter if this test fails to work as expected
254 as the worst that can happen is that some absolute symbols are
255 needlessly converted into section relative symbols. */
256 && in
->n_value
> ((1ULL << (sizeof (in
->n_value
) > 4 ? 32 : 31)) - 1)
257 && in
->n_scnum
== N_ABS
)
261 sec
= bfd_sections_find_if (abfd
, abs_finder
, & in
->n_value
);
264 in
->n_value
-= sec
->vma
;
265 in
->n_scnum
= sec
->target_index
;
267 /* else: FIXME: The value is outside the range of any section. This
268 happens for __image_base__ and __ImageBase and maybe some other
269 symbols as well. We should find a way to handle these values. */
272 H_PUT_32 (abfd
, in
->n_value
, ext
->e_value
);
273 H_PUT_16 (abfd
, in
->n_scnum
, ext
->e_scnum
);
275 if (sizeof (ext
->e_type
) == 2)
276 H_PUT_16 (abfd
, in
->n_type
, ext
->e_type
);
278 H_PUT_32 (abfd
, in
->n_type
, ext
->e_type
);
280 H_PUT_8 (abfd
, in
->n_sclass
, ext
->e_sclass
);
281 H_PUT_8 (abfd
, in
->n_numaux
, ext
->e_numaux
);
287 _bfd_XXi_swap_aux_in (bfd
* abfd
,
291 int indx ATTRIBUTE_UNUSED
,
292 int numaux ATTRIBUTE_UNUSED
,
295 AUXENT
*ext
= (AUXENT
*) ext1
;
296 union internal_auxent
*in
= (union internal_auxent
*) in1
;
298 /* PR 17521: Make sure that all fields in the aux structure
300 memset (in
, 0, sizeof * in
);
304 if (ext
->x_file
.x_fname
[0] == 0)
306 in
->x_file
.x_n
.x_n
.x_zeroes
= 0;
307 in
->x_file
.x_n
.x_n
.x_offset
= H_GET_32 (abfd
, ext
->x_file
.x_n
.x_offset
);
310 memcpy (in
->x_file
.x_n
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
318 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN (abfd
, ext
);
319 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC (abfd
, ext
);
320 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO (abfd
, ext
);
321 in
->x_scn
.x_checksum
= H_GET_32 (abfd
, ext
->x_scn
.x_checksum
);
322 in
->x_scn
.x_associated
= H_GET_16 (abfd
, ext
->x_scn
.x_associated
);
323 in
->x_scn
.x_comdat
= H_GET_8 (abfd
, ext
->x_scn
.x_comdat
);
329 in
->x_sym
.x_tagndx
.l
= H_GET_32 (abfd
, ext
->x_sym
.x_tagndx
);
330 in
->x_sym
.x_tvndx
= H_GET_16 (abfd
, ext
->x_sym
.x_tvndx
);
332 if (in_class
== C_BLOCK
|| in_class
== C_FCN
|| ISFCN (type
)
335 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR (abfd
, ext
);
336 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX (abfd
, ext
);
340 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0] =
341 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
342 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1] =
343 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
344 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2] =
345 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
346 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3] =
347 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
352 in
->x_sym
.x_misc
.x_fsize
= H_GET_32 (abfd
, ext
->x_sym
.x_misc
.x_fsize
);
356 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO (abfd
, ext
);
357 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE (abfd
, ext
);
362 _bfd_XXi_swap_aux_out (bfd
* abfd
,
366 int indx ATTRIBUTE_UNUSED
,
367 int numaux ATTRIBUTE_UNUSED
,
370 union internal_auxent
*in
= (union internal_auxent
*) inp
;
371 AUXENT
*ext
= (AUXENT
*) extp
;
373 memset (ext
, 0, AUXESZ
);
378 if (in
->x_file
.x_n
.x_fname
[0] == 0)
380 H_PUT_32 (abfd
, 0, ext
->x_file
.x_n
.x_zeroes
);
381 H_PUT_32 (abfd
, in
->x_file
.x_n
.x_n
.x_offset
, ext
->x_file
.x_n
.x_offset
);
384 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_n
.x_fname
, sizeof (ext
->x_file
.x_fname
));
393 PUT_SCN_SCNLEN (abfd
, in
->x_scn
.x_scnlen
, ext
);
394 PUT_SCN_NRELOC (abfd
, in
->x_scn
.x_nreloc
, ext
);
395 PUT_SCN_NLINNO (abfd
, in
->x_scn
.x_nlinno
, ext
);
396 H_PUT_32 (abfd
, in
->x_scn
.x_checksum
, ext
->x_scn
.x_checksum
);
397 H_PUT_16 (abfd
, in
->x_scn
.x_associated
, ext
->x_scn
.x_associated
);
398 H_PUT_8 (abfd
, in
->x_scn
.x_comdat
, ext
->x_scn
.x_comdat
);
404 H_PUT_32 (abfd
, in
->x_sym
.x_tagndx
.l
, ext
->x_sym
.x_tagndx
);
405 H_PUT_16 (abfd
, in
->x_sym
.x_tvndx
, ext
->x_sym
.x_tvndx
);
407 if (in_class
== C_BLOCK
|| in_class
== C_FCN
|| ISFCN (type
)
410 PUT_FCN_LNNOPTR (abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
411 PUT_FCN_ENDNDX (abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
415 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0],
416 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
417 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1],
418 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
419 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2],
420 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
421 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3],
422 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
426 H_PUT_32 (abfd
, in
->x_sym
.x_misc
.x_fsize
, ext
->x_sym
.x_misc
.x_fsize
);
429 PUT_LNSZ_LNNO (abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
430 PUT_LNSZ_SIZE (abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
437 _bfd_XXi_swap_lineno_in (bfd
* abfd
, void * ext1
, void * in1
)
439 LINENO
*ext
= (LINENO
*) ext1
;
440 struct internal_lineno
*in
= (struct internal_lineno
*) in1
;
442 in
->l_addr
.l_symndx
= H_GET_32 (abfd
, ext
->l_addr
.l_symndx
);
443 in
->l_lnno
= GET_LINENO_LNNO (abfd
, ext
);
447 _bfd_XXi_swap_lineno_out (bfd
* abfd
, void * inp
, void * outp
)
449 struct internal_lineno
*in
= (struct internal_lineno
*) inp
;
450 struct external_lineno
*ext
= (struct external_lineno
*) outp
;
451 H_PUT_32 (abfd
, in
->l_addr
.l_symndx
, ext
->l_addr
.l_symndx
);
453 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
458 _bfd_XXi_swap_aouthdr_in (bfd
* abfd
,
462 PEAOUTHDR
* src
= (PEAOUTHDR
*) aouthdr_ext1
;
463 AOUTHDR
* aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
464 struct internal_aouthdr
*aouthdr_int
465 = (struct internal_aouthdr
*) aouthdr_int1
;
466 struct internal_extra_pe_aouthdr
*a
= &aouthdr_int
->pe
;
468 aouthdr_int
->magic
= H_GET_16 (abfd
, aouthdr_ext
->magic
);
469 aouthdr_int
->vstamp
= H_GET_16 (abfd
, aouthdr_ext
->vstamp
);
470 aouthdr_int
->tsize
= GET_AOUTHDR_TSIZE (abfd
, aouthdr_ext
->tsize
);
471 aouthdr_int
->dsize
= GET_AOUTHDR_DSIZE (abfd
, aouthdr_ext
->dsize
);
472 aouthdr_int
->bsize
= GET_AOUTHDR_BSIZE (abfd
, aouthdr_ext
->bsize
);
473 aouthdr_int
->entry
= GET_AOUTHDR_ENTRY (abfd
, aouthdr_ext
->entry
);
474 aouthdr_int
->text_start
=
475 GET_AOUTHDR_TEXT_START (abfd
, aouthdr_ext
->text_start
);
477 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
478 /* PE32+ does not have data_start member! */
479 aouthdr_int
->data_start
=
480 GET_AOUTHDR_DATA_START (abfd
, aouthdr_ext
->data_start
);
481 a
->BaseOfData
= aouthdr_int
->data_start
;
484 a
->Magic
= aouthdr_int
->magic
;
485 a
->MajorLinkerVersion
= H_GET_8 (abfd
, aouthdr_ext
->vstamp
);
486 a
->MinorLinkerVersion
= H_GET_8 (abfd
, aouthdr_ext
->vstamp
+ 1);
487 a
->SizeOfCode
= aouthdr_int
->tsize
;
488 a
->SizeOfInitializedData
= aouthdr_int
->dsize
;
489 a
->SizeOfUninitializedData
= aouthdr_int
->bsize
;
490 a
->AddressOfEntryPoint
= aouthdr_int
->entry
;
491 a
->BaseOfCode
= aouthdr_int
->text_start
;
492 a
->ImageBase
= GET_OPTHDR_IMAGE_BASE (abfd
, src
->ImageBase
);
493 a
->SectionAlignment
= H_GET_32 (abfd
, src
->SectionAlignment
);
494 a
->FileAlignment
= H_GET_32 (abfd
, src
->FileAlignment
);
495 a
->MajorOperatingSystemVersion
=
496 H_GET_16 (abfd
, src
->MajorOperatingSystemVersion
);
497 a
->MinorOperatingSystemVersion
=
498 H_GET_16 (abfd
, src
->MinorOperatingSystemVersion
);
499 a
->MajorImageVersion
= H_GET_16 (abfd
, src
->MajorImageVersion
);
500 a
->MinorImageVersion
= H_GET_16 (abfd
, src
->MinorImageVersion
);
501 a
->MajorSubsystemVersion
= H_GET_16 (abfd
, src
->MajorSubsystemVersion
);
502 a
->MinorSubsystemVersion
= H_GET_16 (abfd
, src
->MinorSubsystemVersion
);
503 a
->Reserved1
= H_GET_32 (abfd
, src
->Reserved1
);
504 a
->SizeOfImage
= H_GET_32 (abfd
, src
->SizeOfImage
);
505 a
->SizeOfHeaders
= H_GET_32 (abfd
, src
->SizeOfHeaders
);
506 a
->CheckSum
= H_GET_32 (abfd
, src
->CheckSum
);
507 a
->Subsystem
= H_GET_16 (abfd
, src
->Subsystem
);
508 a
->DllCharacteristics
= H_GET_16 (abfd
, src
->DllCharacteristics
);
509 a
->SizeOfStackReserve
=
510 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd
, src
->SizeOfStackReserve
);
511 a
->SizeOfStackCommit
=
512 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd
, src
->SizeOfStackCommit
);
513 a
->SizeOfHeapReserve
=
514 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd
, src
->SizeOfHeapReserve
);
515 a
->SizeOfHeapCommit
=
516 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd
, src
->SizeOfHeapCommit
);
517 a
->LoaderFlags
= H_GET_32 (abfd
, src
->LoaderFlags
);
518 a
->NumberOfRvaAndSizes
= H_GET_32 (abfd
, src
->NumberOfRvaAndSizes
);
520 /* PR 17512: Don't blindly trust NumberOfRvaAndSizes. */
523 idx
< a
->NumberOfRvaAndSizes
&& idx
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
;
526 /* If data directory is empty, rva also should be 0. */
527 int size
= H_GET_32 (abfd
, src
->DataDirectory
[idx
][1]);
528 int vma
= size
? H_GET_32 (abfd
, src
->DataDirectory
[idx
][0]) : 0;
530 a
->DataDirectory
[idx
].Size
= size
;
531 a
->DataDirectory
[idx
].VirtualAddress
= vma
;
534 while (idx
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
)
536 a
->DataDirectory
[idx
].Size
= 0;
537 a
->DataDirectory
[idx
].VirtualAddress
= 0;
541 if (aouthdr_int
->entry
)
543 aouthdr_int
->entry
+= a
->ImageBase
;
544 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
545 aouthdr_int
->entry
&= 0xffffffff;
549 if (aouthdr_int
->tsize
)
551 aouthdr_int
->text_start
+= a
->ImageBase
;
552 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
553 aouthdr_int
->text_start
&= 0xffffffff;
557 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
558 /* PE32+ does not have data_start member! */
559 if (aouthdr_int
->dsize
)
561 aouthdr_int
->data_start
+= a
->ImageBase
;
562 aouthdr_int
->data_start
&= 0xffffffff;
567 /* A support function for below. */
570 add_data_entry (bfd
* abfd
,
571 struct internal_extra_pe_aouthdr
*aout
,
576 asection
*sec
= bfd_get_section_by_name (abfd
, name
);
578 /* Add import directory information if it exists. */
580 && (coff_section_data (abfd
, sec
) != NULL
)
581 && (pei_section_data (abfd
, sec
) != NULL
))
583 /* If data directory is empty, rva also should be 0. */
584 int size
= pei_section_data (abfd
, sec
)->virt_size
;
585 aout
->DataDirectory
[idx
].Size
= size
;
589 aout
->DataDirectory
[idx
].VirtualAddress
=
590 (sec
->vma
- base
) & 0xffffffff;
591 sec
->flags
|= SEC_DATA
;
597 _bfd_XXi_swap_aouthdr_out (bfd
* abfd
, void * in
, void * out
)
599 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*) in
;
600 pe_data_type
*pe
= pe_data (abfd
);
601 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
602 PEAOUTHDR
*aouthdr_out
= (PEAOUTHDR
*) out
;
604 IMAGE_DATA_DIRECTORY idata2
, idata5
, tls
;
606 sa
= extra
->SectionAlignment
;
607 fa
= extra
->FileAlignment
;
608 ib
= extra
->ImageBase
;
610 idata2
= pe
->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
];
611 idata5
= pe
->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
];
612 tls
= pe
->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
];
614 if (aouthdr_in
->tsize
)
616 aouthdr_in
->text_start
-= ib
;
617 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
618 aouthdr_in
->text_start
&= 0xffffffff;
622 if (aouthdr_in
->dsize
)
624 aouthdr_in
->data_start
-= ib
;
625 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
626 aouthdr_in
->data_start
&= 0xffffffff;
630 if (aouthdr_in
->entry
)
632 aouthdr_in
->entry
-= ib
;
633 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
634 aouthdr_in
->entry
&= 0xffffffff;
638 #define FA(x) (((x) + fa -1 ) & (- fa))
639 #define SA(x) (((x) + sa -1 ) & (- sa))
641 /* We like to have the sizes aligned. */
642 aouthdr_in
->bsize
= FA (aouthdr_in
->bsize
);
644 extra
->NumberOfRvaAndSizes
= IMAGE_NUMBEROF_DIRECTORY_ENTRIES
;
646 add_data_entry (abfd
, extra
, PE_EXPORT_TABLE
, ".edata", ib
);
647 add_data_entry (abfd
, extra
, PE_RESOURCE_TABLE
, ".rsrc", ib
);
648 add_data_entry (abfd
, extra
, PE_EXCEPTION_TABLE
, ".pdata", ib
);
650 /* In theory we do not need to call add_data_entry for .idata$2 or
651 .idata$5. It will be done in bfd_coff_final_link where all the
652 required information is available. If however, we are not going
653 to perform a final link, eg because we have been invoked by objcopy
654 or strip, then we need to make sure that these Data Directory
655 entries are initialised properly.
657 So - we copy the input values into the output values, and then, if
658 a final link is going to be performed, it can overwrite them. */
659 extra
->DataDirectory
[PE_IMPORT_TABLE
] = idata2
;
660 extra
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
] = idata5
;
661 extra
->DataDirectory
[PE_TLS_TABLE
] = tls
;
663 if (extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
== 0)
664 /* Until other .idata fixes are made (pending patch), the entry for
665 .idata is needed for backwards compatibility. FIXME. */
666 add_data_entry (abfd
, extra
, PE_IMPORT_TABLE
, ".idata", ib
);
668 /* For some reason, the virtual size (which is what's set by
669 add_data_entry) for .reloc is not the same as the size recorded
670 in this slot by MSVC; it doesn't seem to cause problems (so far),
671 but since it's the best we've got, use it. It does do the right
673 if (pe
->has_reloc_section
)
674 add_data_entry (abfd
, extra
, PE_BASE_RELOCATION_TABLE
, ".reloc", ib
);
683 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
685 int rounded
= FA (sec
->size
);
690 /* The first non-zero section filepos is the header size.
691 Sections without contents will have a filepos of 0. */
693 hsize
= sec
->filepos
;
694 if (sec
->flags
& SEC_DATA
)
696 if (sec
->flags
& SEC_CODE
)
698 /* The image size is the total VIRTUAL size (which is what is
699 in the virt_size field). Files have been seen (from MSVC
700 5.0 link.exe) where the file size of the .data segment is
701 quite small compared to the virtual size. Without this
702 fix, strip munges the file.
704 FIXME: We need to handle holes between sections, which may
705 happpen when we covert from another format. We just use
706 the virtual address and virtual size of the last section
707 for the image size. */
708 if (coff_section_data (abfd
, sec
) != NULL
709 && pei_section_data (abfd
, sec
) != NULL
)
710 isize
= (sec
->vma
- extra
->ImageBase
711 + SA (FA (pei_section_data (abfd
, sec
)->virt_size
)));
714 aouthdr_in
->dsize
= dsize
;
715 aouthdr_in
->tsize
= tsize
;
716 extra
->SizeOfHeaders
= hsize
;
717 extra
->SizeOfImage
= isize
;
720 H_PUT_16 (abfd
, aouthdr_in
->magic
, aouthdr_out
->standard
.magic
);
722 if (extra
->MajorLinkerVersion
|| extra
->MinorLinkerVersion
)
724 H_PUT_8 (abfd
, extra
->MajorLinkerVersion
,
725 aouthdr_out
->standard
.vstamp
);
726 H_PUT_8 (abfd
, extra
->MinorLinkerVersion
,
727 aouthdr_out
->standard
.vstamp
+ 1);
731 /* e.g. 219510000 is linker version 2.19 */
732 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
734 /* This piece of magic sets the "linker version" field to
736 H_PUT_16 (abfd
, (LINKER_VERSION
/ 100 + (LINKER_VERSION
% 100) * 256),
737 aouthdr_out
->standard
.vstamp
);
740 PUT_AOUTHDR_TSIZE (abfd
, aouthdr_in
->tsize
, aouthdr_out
->standard
.tsize
);
741 PUT_AOUTHDR_DSIZE (abfd
, aouthdr_in
->dsize
, aouthdr_out
->standard
.dsize
);
742 PUT_AOUTHDR_BSIZE (abfd
, aouthdr_in
->bsize
, aouthdr_out
->standard
.bsize
);
743 PUT_AOUTHDR_ENTRY (abfd
, aouthdr_in
->entry
, aouthdr_out
->standard
.entry
);
744 PUT_AOUTHDR_TEXT_START (abfd
, aouthdr_in
->text_start
,
745 aouthdr_out
->standard
.text_start
);
747 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
748 /* PE32+ does not have data_start member! */
749 PUT_AOUTHDR_DATA_START (abfd
, aouthdr_in
->data_start
,
750 aouthdr_out
->standard
.data_start
);
753 PUT_OPTHDR_IMAGE_BASE (abfd
, extra
->ImageBase
, aouthdr_out
->ImageBase
);
754 H_PUT_32 (abfd
, extra
->SectionAlignment
, aouthdr_out
->SectionAlignment
);
755 H_PUT_32 (abfd
, extra
->FileAlignment
, aouthdr_out
->FileAlignment
);
756 H_PUT_16 (abfd
, extra
->MajorOperatingSystemVersion
,
757 aouthdr_out
->MajorOperatingSystemVersion
);
758 H_PUT_16 (abfd
, extra
->MinorOperatingSystemVersion
,
759 aouthdr_out
->MinorOperatingSystemVersion
);
760 H_PUT_16 (abfd
, extra
->MajorImageVersion
, aouthdr_out
->MajorImageVersion
);
761 H_PUT_16 (abfd
, extra
->MinorImageVersion
, aouthdr_out
->MinorImageVersion
);
762 H_PUT_16 (abfd
, extra
->MajorSubsystemVersion
,
763 aouthdr_out
->MajorSubsystemVersion
);
764 H_PUT_16 (abfd
, extra
->MinorSubsystemVersion
,
765 aouthdr_out
->MinorSubsystemVersion
);
766 H_PUT_32 (abfd
, extra
->Reserved1
, aouthdr_out
->Reserved1
);
767 H_PUT_32 (abfd
, extra
->SizeOfImage
, aouthdr_out
->SizeOfImage
);
768 H_PUT_32 (abfd
, extra
->SizeOfHeaders
, aouthdr_out
->SizeOfHeaders
);
769 H_PUT_32 (abfd
, extra
->CheckSum
, aouthdr_out
->CheckSum
);
770 H_PUT_16 (abfd
, extra
->Subsystem
, aouthdr_out
->Subsystem
);
771 H_PUT_16 (abfd
, extra
->DllCharacteristics
, aouthdr_out
->DllCharacteristics
);
772 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd
, extra
->SizeOfStackReserve
,
773 aouthdr_out
->SizeOfStackReserve
);
774 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd
, extra
->SizeOfStackCommit
,
775 aouthdr_out
->SizeOfStackCommit
);
776 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd
, extra
->SizeOfHeapReserve
,
777 aouthdr_out
->SizeOfHeapReserve
);
778 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd
, extra
->SizeOfHeapCommit
,
779 aouthdr_out
->SizeOfHeapCommit
);
780 H_PUT_32 (abfd
, extra
->LoaderFlags
, aouthdr_out
->LoaderFlags
);
781 H_PUT_32 (abfd
, extra
->NumberOfRvaAndSizes
,
782 aouthdr_out
->NumberOfRvaAndSizes
);
786 for (idx
= 0; idx
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; idx
++)
788 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].VirtualAddress
,
789 aouthdr_out
->DataDirectory
[idx
][0]);
790 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].Size
,
791 aouthdr_out
->DataDirectory
[idx
][1]);
799 _bfd_XXi_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
802 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
803 struct external_PEI_filehdr
*filehdr_out
= (struct external_PEI_filehdr
*) out
;
805 if (pe_data (abfd
)->has_reloc_section
806 || pe_data (abfd
)->dont_strip_reloc
)
807 filehdr_in
->f_flags
&= ~F_RELFLG
;
809 if (pe_data (abfd
)->dll
)
810 filehdr_in
->f_flags
|= F_DLL
;
812 filehdr_in
->pe
.e_magic
= IMAGE_DOS_SIGNATURE
;
813 filehdr_in
->pe
.e_cblp
= 0x90;
814 filehdr_in
->pe
.e_cp
= 0x3;
815 filehdr_in
->pe
.e_crlc
= 0x0;
816 filehdr_in
->pe
.e_cparhdr
= 0x4;
817 filehdr_in
->pe
.e_minalloc
= 0x0;
818 filehdr_in
->pe
.e_maxalloc
= 0xffff;
819 filehdr_in
->pe
.e_ss
= 0x0;
820 filehdr_in
->pe
.e_sp
= 0xb8;
821 filehdr_in
->pe
.e_csum
= 0x0;
822 filehdr_in
->pe
.e_ip
= 0x0;
823 filehdr_in
->pe
.e_cs
= 0x0;
824 filehdr_in
->pe
.e_lfarlc
= 0x40;
825 filehdr_in
->pe
.e_ovno
= 0x0;
827 for (idx
= 0; idx
< 4; idx
++)
828 filehdr_in
->pe
.e_res
[idx
] = 0x0;
830 filehdr_in
->pe
.e_oemid
= 0x0;
831 filehdr_in
->pe
.e_oeminfo
= 0x0;
833 for (idx
= 0; idx
< 10; idx
++)
834 filehdr_in
->pe
.e_res2
[idx
] = 0x0;
836 filehdr_in
->pe
.e_lfanew
= 0x80;
838 /* This next collection of data are mostly just characters. It
839 appears to be constant within the headers put on NT exes. */
840 memcpy (filehdr_in
->pe
.dos_message
, pe_data (abfd
)->dos_message
,
841 sizeof (filehdr_in
->pe
.dos_message
));
843 filehdr_in
->pe
.nt_signature
= IMAGE_NT_SIGNATURE
;
845 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
846 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
848 /* Use a real timestamp by default, unless the no-insert-timestamp
849 option was chosen. */
850 if ((pe_data (abfd
)->timestamp
) == -1)
851 H_PUT_32 (abfd
, time (0), filehdr_out
->f_timdat
);
853 H_PUT_32 (abfd
, pe_data (abfd
)->timestamp
, filehdr_out
->f_timdat
);
855 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
856 filehdr_out
->f_symptr
);
857 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
858 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
859 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
861 /* Put in extra dos header stuff. This data remains essentially
862 constant, it just has to be tacked on to the beginning of all exes
864 H_PUT_16 (abfd
, filehdr_in
->pe
.e_magic
, filehdr_out
->e_magic
);
865 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cblp
, filehdr_out
->e_cblp
);
866 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cp
, filehdr_out
->e_cp
);
867 H_PUT_16 (abfd
, filehdr_in
->pe
.e_crlc
, filehdr_out
->e_crlc
);
868 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cparhdr
, filehdr_out
->e_cparhdr
);
869 H_PUT_16 (abfd
, filehdr_in
->pe
.e_minalloc
, filehdr_out
->e_minalloc
);
870 H_PUT_16 (abfd
, filehdr_in
->pe
.e_maxalloc
, filehdr_out
->e_maxalloc
);
871 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ss
, filehdr_out
->e_ss
);
872 H_PUT_16 (abfd
, filehdr_in
->pe
.e_sp
, filehdr_out
->e_sp
);
873 H_PUT_16 (abfd
, filehdr_in
->pe
.e_csum
, filehdr_out
->e_csum
);
874 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ip
, filehdr_out
->e_ip
);
875 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cs
, filehdr_out
->e_cs
);
876 H_PUT_16 (abfd
, filehdr_in
->pe
.e_lfarlc
, filehdr_out
->e_lfarlc
);
877 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ovno
, filehdr_out
->e_ovno
);
879 for (idx
= 0; idx
< 4; idx
++)
880 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res
[idx
], filehdr_out
->e_res
[idx
]);
882 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oemid
, filehdr_out
->e_oemid
);
883 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oeminfo
, filehdr_out
->e_oeminfo
);
885 for (idx
= 0; idx
< 10; idx
++)
886 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res2
[idx
], filehdr_out
->e_res2
[idx
]);
888 H_PUT_32 (abfd
, filehdr_in
->pe
.e_lfanew
, filehdr_out
->e_lfanew
);
890 for (idx
= 0; idx
< 16; idx
++)
891 H_PUT_32 (abfd
, filehdr_in
->pe
.dos_message
[idx
],
892 filehdr_out
->dos_message
[idx
]);
894 /* Also put in the NT signature. */
895 H_PUT_32 (abfd
, filehdr_in
->pe
.nt_signature
, filehdr_out
->nt_signature
);
901 _bfd_XX_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
903 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
904 FILHDR
*filehdr_out
= (FILHDR
*) out
;
906 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
907 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
908 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->f_timdat
);
909 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
, filehdr_out
->f_symptr
);
910 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
911 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
912 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
918 _bfd_XXi_swap_scnhdr_out (bfd
* abfd
, void * in
, void * out
)
920 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*) in
;
921 SCNHDR
*scnhdr_ext
= (SCNHDR
*) out
;
922 unsigned int ret
= SCNHSZ
;
926 memcpy (scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof (scnhdr_int
->s_name
));
928 ss
= scnhdr_int
->s_vaddr
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
929 if (scnhdr_int
->s_vaddr
< pe_data (abfd
)->pe_opthdr
.ImageBase
)
930 _bfd_error_handler (_("%pB:%.8s: section below image base"),
931 abfd
, scnhdr_int
->s_name
);
932 /* Do not compare lower 32-bits for 64-bit vma. */
933 #if !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
934 else if(ss
!= (ss
& 0xffffffff))
935 _bfd_error_handler (_("%pB:%.8s: RVA truncated"), abfd
, scnhdr_int
->s_name
);
936 PUT_SCNHDR_VADDR (abfd
, ss
& 0xffffffff, scnhdr_ext
->s_vaddr
);
938 PUT_SCNHDR_VADDR (abfd
, ss
, scnhdr_ext
->s_vaddr
);
941 /* NT wants the size data to be rounded up to the next
942 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
944 if ((scnhdr_int
->s_flags
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
) != 0)
946 if (bfd_pei_p (abfd
))
948 ps
= scnhdr_int
->s_size
;
954 ss
= scnhdr_int
->s_size
;
959 if (bfd_pei_p (abfd
))
960 ps
= scnhdr_int
->s_paddr
;
964 ss
= scnhdr_int
->s_size
;
967 PUT_SCNHDR_SIZE (abfd
, ss
,
970 /* s_paddr in PE is really the virtual size. */
971 PUT_SCNHDR_PADDR (abfd
, ps
, scnhdr_ext
->s_paddr
);
973 PUT_SCNHDR_SCNPTR (abfd
, scnhdr_int
->s_scnptr
,
974 scnhdr_ext
->s_scnptr
);
975 PUT_SCNHDR_RELPTR (abfd
, scnhdr_int
->s_relptr
,
976 scnhdr_ext
->s_relptr
);
977 PUT_SCNHDR_LNNOPTR (abfd
, scnhdr_int
->s_lnnoptr
,
978 scnhdr_ext
->s_lnnoptr
);
981 /* Extra flags must be set when dealing with PE. All sections should also
982 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
983 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
984 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
985 (this is especially important when dealing with the .idata section since
986 the addresses for routines from .dlls must be overwritten). If .reloc
987 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
988 (0x02000000). Also, the resource data should also be read and
991 /* FIXME: Alignment is also encoded in this field, at least on
992 ARM-WINCE. Although - how do we get the original alignment field
997 char section_name
[SCNNMLEN
];
998 unsigned long must_have
;
1000 pe_required_section_flags
;
1002 pe_required_section_flags known_sections
[] =
1004 { ".arch", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
| IMAGE_SCN_ALIGN_8BYTES
},
1005 { ".bss", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1006 { ".data", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1007 { ".edata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1008 { ".idata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1009 { ".pdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1010 { ".rdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1011 { ".reloc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
},
1012 { ".rsrc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1013 { ".text" , IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_CODE
| IMAGE_SCN_MEM_EXECUTE
},
1014 { ".tls", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1015 { ".xdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1018 pe_required_section_flags
* p
;
1020 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1021 we know exactly what this specific section wants so we remove it
1022 and then allow the must_have field to add it back in if necessary.
1023 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1024 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
1025 by ld --enable-auto-import (if auto-import is actually needed),
1026 by ld --omagic, or by obcopy --writable-text. */
1028 for (p
= known_sections
;
1029 p
< known_sections
+ ARRAY_SIZE (known_sections
);
1031 if (memcmp (scnhdr_int
->s_name
, p
->section_name
, SCNNMLEN
) == 0)
1033 if (memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text")
1034 || (bfd_get_file_flags (abfd
) & WP_TEXT
))
1035 scnhdr_int
->s_flags
&= ~IMAGE_SCN_MEM_WRITE
;
1036 scnhdr_int
->s_flags
|= p
->must_have
;
1040 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1043 if (coff_data (abfd
)->link_info
1044 && ! bfd_link_relocatable (coff_data (abfd
)->link_info
)
1045 && ! bfd_link_pic (coff_data (abfd
)->link_info
)
1046 && memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text") == 0)
1048 /* By inference from looking at MS output, the 32 bit field
1049 which is the combination of the number_of_relocs and
1050 number_of_linenos is used for the line number count in
1051 executables. A 16-bit field won't do for cc1. The MS
1052 document says that the number of relocs is zero for
1053 executables, but the 17-th bit has been observed to be there.
1054 Overflow is not an issue: a 4G-line program will overflow a
1055 bunch of other fields long before this! */
1056 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
& 0xffff), scnhdr_ext
->s_nlnno
);
1057 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
>> 16), scnhdr_ext
->s_nreloc
);
1061 if (scnhdr_int
->s_nlnno
<= 0xffff)
1062 H_PUT_16 (abfd
, scnhdr_int
->s_nlnno
, scnhdr_ext
->s_nlnno
);
1065 /* xgettext:c-format */
1066 _bfd_error_handler (_("%pB: line number overflow: 0x%lx > 0xffff"),
1067 abfd
, scnhdr_int
->s_nlnno
);
1068 bfd_set_error (bfd_error_file_truncated
);
1069 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nlnno
);
1073 /* Although we could encode 0xffff relocs here, we do not, to be
1074 consistent with other parts of bfd. Also it lets us warn, as
1075 we should never see 0xffff here w/o having the overflow flag
1077 if (scnhdr_int
->s_nreloc
< 0xffff)
1078 H_PUT_16 (abfd
, scnhdr_int
->s_nreloc
, scnhdr_ext
->s_nreloc
);
1081 /* PE can deal with large #s of relocs, but not here. */
1082 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nreloc
);
1083 scnhdr_int
->s_flags
|= IMAGE_SCN_LNK_NRELOC_OVFL
;
1084 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1091 _bfd_XXi_swap_debugdir_in (bfd
* abfd
, void * ext1
, void * in1
)
1093 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) ext1
;
1094 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) in1
;
1096 in
->Characteristics
= H_GET_32(abfd
, ext
->Characteristics
);
1097 in
->TimeDateStamp
= H_GET_32(abfd
, ext
->TimeDateStamp
);
1098 in
->MajorVersion
= H_GET_16(abfd
, ext
->MajorVersion
);
1099 in
->MinorVersion
= H_GET_16(abfd
, ext
->MinorVersion
);
1100 in
->Type
= H_GET_32(abfd
, ext
->Type
);
1101 in
->SizeOfData
= H_GET_32(abfd
, ext
->SizeOfData
);
1102 in
->AddressOfRawData
= H_GET_32(abfd
, ext
->AddressOfRawData
);
1103 in
->PointerToRawData
= H_GET_32(abfd
, ext
->PointerToRawData
);
1107 _bfd_XXi_swap_debugdir_out (bfd
* abfd
, void * inp
, void * extp
)
1109 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) extp
;
1110 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) inp
;
1112 H_PUT_32(abfd
, in
->Characteristics
, ext
->Characteristics
);
1113 H_PUT_32(abfd
, in
->TimeDateStamp
, ext
->TimeDateStamp
);
1114 H_PUT_16(abfd
, in
->MajorVersion
, ext
->MajorVersion
);
1115 H_PUT_16(abfd
, in
->MinorVersion
, ext
->MinorVersion
);
1116 H_PUT_32(abfd
, in
->Type
, ext
->Type
);
1117 H_PUT_32(abfd
, in
->SizeOfData
, ext
->SizeOfData
);
1118 H_PUT_32(abfd
, in
->AddressOfRawData
, ext
->AddressOfRawData
);
1119 H_PUT_32(abfd
, in
->PointerToRawData
, ext
->PointerToRawData
);
1121 return sizeof (struct external_IMAGE_DEBUG_DIRECTORY
);
1125 _bfd_XXi_slurp_codeview_record (bfd
* abfd
, file_ptr where
, unsigned long length
, CODEVIEW_INFO
*cvinfo
,
1129 bfd_size_type nread
;
1131 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1134 if (length
<= sizeof (CV_INFO_PDB70
) && length
<= sizeof (CV_INFO_PDB20
))
1138 nread
= bfd_bread (buffer
, length
, abfd
);
1139 if (length
!= nread
)
1142 /* Ensure null termination of filename. */
1143 memset (buffer
+ nread
, 0, sizeof (buffer
) - nread
);
1145 cvinfo
->CVSignature
= H_GET_32 (abfd
, buffer
);
1148 if ((cvinfo
->CVSignature
== CVINFO_PDB70_CVSIGNATURE
)
1149 && (length
> sizeof (CV_INFO_PDB70
)))
1151 CV_INFO_PDB70
*cvinfo70
= (CV_INFO_PDB70
*)(buffer
);
1153 cvinfo
->Age
= H_GET_32(abfd
, cvinfo70
->Age
);
1155 /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1156 by 8 single bytes. Byte swap them so we can conveniently treat the GUID
1157 as 16 bytes in big-endian order. */
1158 bfd_putb32 (bfd_getl32 (cvinfo70
->Signature
), cvinfo
->Signature
);
1159 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[4])), &(cvinfo
->Signature
[4]));
1160 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[6])), &(cvinfo
->Signature
[6]));
1161 memcpy (&(cvinfo
->Signature
[8]), &(cvinfo70
->Signature
[8]), 8);
1163 cvinfo
->SignatureLength
= CV_INFO_SIGNATURE_LENGTH
;
1164 /* cvinfo->PdbFileName = cvinfo70->PdbFileName; */
1167 *pdb
= xstrdup (cvinfo70
->PdbFileName
);
1171 else if ((cvinfo
->CVSignature
== CVINFO_PDB20_CVSIGNATURE
)
1172 && (length
> sizeof (CV_INFO_PDB20
)))
1174 CV_INFO_PDB20
*cvinfo20
= (CV_INFO_PDB20
*)(buffer
);
1175 cvinfo
->Age
= H_GET_32(abfd
, cvinfo20
->Age
);
1176 memcpy (cvinfo
->Signature
, cvinfo20
->Signature
, 4);
1177 cvinfo
->SignatureLength
= 4;
1178 /* cvinfo->PdbFileName = cvinfo20->PdbFileName; */
1181 *pdb
= xstrdup (cvinfo20
->PdbFileName
);
1190 _bfd_XXi_write_codeview_record (bfd
* abfd
, file_ptr where
, CODEVIEW_INFO
*cvinfo
,
1193 size_t pdb_len
= pdb
? strlen (pdb
) : 0;
1194 const bfd_size_type size
= sizeof (CV_INFO_PDB70
) + pdb_len
+ 1;
1195 bfd_size_type written
;
1196 CV_INFO_PDB70
*cvinfo70
;
1199 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1202 buffer
= bfd_malloc (size
);
1206 cvinfo70
= (CV_INFO_PDB70
*) buffer
;
1207 H_PUT_32 (abfd
, CVINFO_PDB70_CVSIGNATURE
, cvinfo70
->CvSignature
);
1209 /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1210 in little-endian order, followed by 8 single bytes. */
1211 bfd_putl32 (bfd_getb32 (cvinfo
->Signature
), cvinfo70
->Signature
);
1212 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[4])), &(cvinfo70
->Signature
[4]));
1213 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[6])), &(cvinfo70
->Signature
[6]));
1214 memcpy (&(cvinfo70
->Signature
[8]), &(cvinfo
->Signature
[8]), 8);
1216 H_PUT_32 (abfd
, cvinfo
->Age
, cvinfo70
->Age
);
1219 cvinfo70
->PdbFileName
[0] = '\0';
1221 memcpy (cvinfo70
->PdbFileName
, pdb
, pdb_len
+ 1);
1223 written
= bfd_bwrite (buffer
, size
, abfd
);
1227 return written
== size
? size
: 0;
1230 static char * dir_names
[IMAGE_NUMBEROF_DIRECTORY_ENTRIES
] =
1232 N_("Export Directory [.edata (or where ever we found it)]"),
1233 N_("Import Directory [parts of .idata]"),
1234 N_("Resource Directory [.rsrc]"),
1235 N_("Exception Directory [.pdata]"),
1236 N_("Security Directory"),
1237 N_("Base Relocation Directory [.reloc]"),
1238 N_("Debug Directory"),
1239 N_("Description Directory"),
1240 N_("Special Directory"),
1241 N_("Thread Storage Directory [.tls]"),
1242 N_("Load Configuration Directory"),
1243 N_("Bound Import Directory"),
1244 N_("Import Address Table Directory"),
1245 N_("Delay Import Directory"),
1246 N_("CLR Runtime Header"),
1251 pe_print_idata (bfd
* abfd
, void * vfile
)
1253 FILE *file
= (FILE *) vfile
;
1257 bfd_size_type datasize
= 0;
1258 bfd_size_type dataoff
;
1262 pe_data_type
*pe
= pe_data (abfd
);
1263 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1267 addr
= extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
;
1269 if (addr
== 0 && extra
->DataDirectory
[PE_IMPORT_TABLE
].Size
== 0)
1271 /* Maybe the extra header isn't there. Look for the section. */
1272 section
= bfd_get_section_by_name (abfd
, ".idata");
1273 if (section
== NULL
)
1276 addr
= section
->vma
;
1277 datasize
= section
->size
;
1283 addr
+= extra
->ImageBase
;
1284 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1286 datasize
= section
->size
;
1287 if (addr
>= section
->vma
&& addr
< section
->vma
+ datasize
)
1291 if (section
== NULL
)
1294 _("\nThere is an import table, but the section containing it could not be found\n"));
1297 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1300 _("\nThere is an import table in %s, but that section has no contents\n"),
1306 /* xgettext:c-format */
1307 fprintf (file
, _("\nThere is an import table in %s at 0x%lx\n"),
1308 section
->name
, (unsigned long) addr
);
1310 dataoff
= addr
- section
->vma
;
1313 _("\nThe Import Tables (interpreted %s section contents)\n"),
1317 vma: Hint Time Forward DLL First\n\
1318 Table Stamp Chain Name Thunk\n"));
1320 /* Read the whole section. Some of the fields might be before dataoff. */
1321 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
1327 adj
= section
->vma
- extra
->ImageBase
;
1329 /* Print all image import descriptors. */
1330 for (i
= dataoff
; i
+ onaline
<= datasize
; i
+= onaline
)
1334 bfd_vma forward_chain
;
1336 bfd_vma first_thunk
;
1341 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1342 fprintf (file
, " %08lx\t", (unsigned long) (i
+ adj
));
1343 hint_addr
= bfd_get_32 (abfd
, data
+ i
);
1344 time_stamp
= bfd_get_32 (abfd
, data
+ i
+ 4);
1345 forward_chain
= bfd_get_32 (abfd
, data
+ i
+ 8);
1346 dll_name
= bfd_get_32 (abfd
, data
+ i
+ 12);
1347 first_thunk
= bfd_get_32 (abfd
, data
+ i
+ 16);
1349 fprintf (file
, "%08lx %08lx %08lx %08lx %08lx\n",
1350 (unsigned long) hint_addr
,
1351 (unsigned long) time_stamp
,
1352 (unsigned long) forward_chain
,
1353 (unsigned long) dll_name
,
1354 (unsigned long) first_thunk
);
1356 if (hint_addr
== 0 && first_thunk
== 0)
1359 if (dll_name
- adj
>= section
->size
)
1362 dll
= (char *) data
+ dll_name
- adj
;
1363 /* PR 17512 file: 078-12277-0.004. */
1364 bfd_size_type maxlen
= (char *)(data
+ datasize
) - dll
- 1;
1365 fprintf (file
, _("\n\tDLL Name: %.*s\n"), (int) maxlen
, dll
);
1367 /* PR 21546: When the Hint Address is zero,
1368 we try the First Thunk instead. */
1370 hint_addr
= first_thunk
;
1372 if (hint_addr
!= 0 && hint_addr
- adj
< datasize
)
1375 asection
*ft_section
;
1377 bfd_size_type ft_datasize
;
1381 fprintf (file
, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1383 idx
= hint_addr
- adj
;
1385 ft_addr
= first_thunk
+ extra
->ImageBase
;
1386 ft_idx
= first_thunk
- adj
;
1387 ft_data
= data
+ ft_idx
;
1388 ft_datasize
= datasize
- ft_idx
;
1391 if (first_thunk
!= hint_addr
)
1393 /* Find the section which contains the first thunk. */
1394 for (ft_section
= abfd
->sections
;
1396 ft_section
= ft_section
->next
)
1398 if (ft_addr
>= ft_section
->vma
1399 && ft_addr
< ft_section
->vma
+ ft_section
->size
)
1403 if (ft_section
== NULL
)
1406 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1410 /* Now check to see if this section is the same as our current
1411 section. If it is not then we will have to load its data in. */
1412 if (ft_section
!= section
)
1414 ft_idx
= first_thunk
- (ft_section
->vma
- extra
->ImageBase
);
1415 ft_datasize
= ft_section
->size
- ft_idx
;
1416 ft_data
= (bfd_byte
*) bfd_malloc (ft_datasize
);
1417 if (ft_data
== NULL
)
1420 /* Read ft_datasize bytes starting at offset ft_idx. */
1421 if (!bfd_get_section_contents (abfd
, ft_section
, ft_data
,
1422 (bfd_vma
) ft_idx
, ft_datasize
))
1431 /* Print HintName vector entries. */
1432 #ifdef COFF_WITH_pex64
1433 for (j
= 0; idx
+ j
+ 8 <= datasize
; j
+= 8)
1436 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1437 unsigned long member_high
= bfd_get_32 (abfd
, data
+ idx
+ j
+ 4);
1439 if (!member
&& !member_high
)
1444 if (HighBitSet (member_high
))
1445 fprintf (file
, "\t%lx%08lx\t %4lx%08lx <none>",
1446 member_high
, member
,
1447 WithoutHighBit (member_high
), member
);
1448 /* PR binutils/17512: Handle corrupt PE data. */
1449 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1450 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1456 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1457 member_name
= (char *) data
+ amt
+ 2;
1458 fprintf (file
, "\t%04lx\t %4d %.*s",member
, ordinal
,
1459 (int) (datasize
- (amt
+ 2)), member_name
);
1462 /* If the time stamp is not zero, the import address
1463 table holds actual addresses. */
1466 && first_thunk
!= hint_addr
1467 && j
+ 4 <= ft_datasize
)
1468 fprintf (file
, "\t%04lx",
1469 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1470 fprintf (file
, "\n");
1473 for (j
= 0; idx
+ j
+ 4 <= datasize
; j
+= 4)
1476 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1478 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1484 if (HighBitSet (member
))
1485 fprintf (file
, "\t%04lx\t %4lu <none>",
1486 member
, WithoutHighBit (member
));
1487 /* PR binutils/17512: Handle corrupt PE data. */
1488 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1489 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1495 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1496 member_name
= (char *) data
+ amt
+ 2;
1497 fprintf (file
, "\t%04lx\t %4d %.*s",
1499 (int) (datasize
- (amt
+ 2)), member_name
);
1502 /* If the time stamp is not zero, the import address
1503 table holds actual addresses. */
1506 && first_thunk
!= hint_addr
1507 && j
+ 4 <= ft_datasize
)
1508 fprintf (file
, "\t%04lx",
1509 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1511 fprintf (file
, "\n");
1518 fprintf (file
, "\n");
1527 pe_print_edata (bfd
* abfd
, void * vfile
)
1529 FILE *file
= (FILE *) vfile
;
1532 bfd_size_type datasize
= 0;
1533 bfd_size_type dataoff
;
1538 long export_flags
; /* Reserved - should be zero. */
1542 bfd_vma name
; /* RVA - relative to image base. */
1543 long base
; /* Ordinal base. */
1544 unsigned long num_functions
;/* Number in the export address table. */
1545 unsigned long num_names
; /* Number in the name pointer table. */
1546 bfd_vma eat_addr
; /* RVA to the export address table. */
1547 bfd_vma npt_addr
; /* RVA to the Export Name Pointer Table. */
1548 bfd_vma ot_addr
; /* RVA to the Ordinal Table. */
1551 pe_data_type
*pe
= pe_data (abfd
);
1552 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1556 addr
= extra
->DataDirectory
[PE_EXPORT_TABLE
].VirtualAddress
;
1558 if (addr
== 0 && extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
== 0)
1560 /* Maybe the extra header isn't there. Look for the section. */
1561 section
= bfd_get_section_by_name (abfd
, ".edata");
1562 if (section
== NULL
)
1565 addr
= section
->vma
;
1567 datasize
= section
->size
;
1573 addr
+= extra
->ImageBase
;
1575 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1576 if (addr
>= section
->vma
&& addr
< section
->vma
+ section
->size
)
1579 if (section
== NULL
)
1582 _("\nThere is an export table, but the section containing it could not be found\n"));
1585 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1588 _("\nThere is an export table in %s, but that section has no contents\n"),
1593 dataoff
= addr
- section
->vma
;
1594 datasize
= extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
;
1595 if (dataoff
> section
->size
1596 || datasize
> section
->size
- dataoff
)
1599 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1605 /* PR 17512: Handle corrupt PE binaries. */
1609 /* xgettext:c-format */
1610 _("\nThere is an export table in %s, but it is too small (%d)\n"),
1611 section
->name
, (int) datasize
);
1615 /* xgettext:c-format */
1616 fprintf (file
, _("\nThere is an export table in %s at 0x%lx\n"),
1617 section
->name
, (unsigned long) addr
);
1619 data
= (bfd_byte
*) bfd_malloc (datasize
);
1623 if (! bfd_get_section_contents (abfd
, section
, data
,
1624 (file_ptr
) dataoff
, datasize
))
1627 /* Go get Export Directory Table. */
1628 edt
.export_flags
= bfd_get_32 (abfd
, data
+ 0);
1629 edt
.time_stamp
= bfd_get_32 (abfd
, data
+ 4);
1630 edt
.major_ver
= bfd_get_16 (abfd
, data
+ 8);
1631 edt
.minor_ver
= bfd_get_16 (abfd
, data
+ 10);
1632 edt
.name
= bfd_get_32 (abfd
, data
+ 12);
1633 edt
.base
= bfd_get_32 (abfd
, data
+ 16);
1634 edt
.num_functions
= bfd_get_32 (abfd
, data
+ 20);
1635 edt
.num_names
= bfd_get_32 (abfd
, data
+ 24);
1636 edt
.eat_addr
= bfd_get_32 (abfd
, data
+ 28);
1637 edt
.npt_addr
= bfd_get_32 (abfd
, data
+ 32);
1638 edt
.ot_addr
= bfd_get_32 (abfd
, data
+ 36);
1640 adj
= section
->vma
- extra
->ImageBase
+ dataoff
;
1642 /* Dump the EDT first. */
1644 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1648 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt
.export_flags
);
1651 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt
.time_stamp
);
1654 /* xgettext:c-format */
1655 _("Major/Minor \t\t\t%d/%d\n"), edt
.major_ver
, edt
.minor_ver
);
1658 _("Name \t\t\t\t"));
1659 bfd_fprintf_vma (abfd
, file
, edt
.name
);
1661 if ((edt
.name
>= adj
) && (edt
.name
< adj
+ datasize
))
1662 fprintf (file
, " %.*s\n",
1663 (int) (datasize
- (edt
.name
- adj
)),
1664 data
+ edt
.name
- adj
);
1666 fprintf (file
, "(outside .edata section)\n");
1669 _("Ordinal Base \t\t\t%ld\n"), edt
.base
);
1675 _("\tExport Address Table \t\t%08lx\n"),
1679 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt
.num_names
);
1682 _("Table Addresses\n"));
1685 _("\tExport Address Table \t\t"));
1686 bfd_fprintf_vma (abfd
, file
, edt
.eat_addr
);
1687 fprintf (file
, "\n");
1690 _("\tName Pointer Table \t\t"));
1691 bfd_fprintf_vma (abfd
, file
, edt
.npt_addr
);
1692 fprintf (file
, "\n");
1695 _("\tOrdinal Table \t\t\t"));
1696 bfd_fprintf_vma (abfd
, file
, edt
.ot_addr
);
1697 fprintf (file
, "\n");
1699 /* The next table to find is the Export Address Table. It's basically
1700 a list of pointers that either locate a function in this dll, or
1701 forward the call to another dll. Something like:
1706 } export_address_table_entry; */
1709 _("\nExport Address Table -- Ordinal Base %ld\n"),
1712 /* PR 17512: Handle corrupt PE binaries. */
1713 /* PR 17512 file: 140-165018-0.004. */
1714 if (edt
.eat_addr
- adj
>= datasize
1715 /* PR 17512: file: 092b1829 */
1716 || (edt
.num_functions
+ 1) * 4 < edt
.num_functions
1717 || edt
.eat_addr
- adj
+ (edt
.num_functions
+ 1) * 4 > datasize
)
1718 fprintf (file
, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1719 (long) edt
.eat_addr
,
1720 (long) edt
.num_functions
);
1721 else for (i
= 0; i
< edt
.num_functions
; ++i
)
1723 bfd_vma eat_member
= bfd_get_32 (abfd
,
1724 data
+ edt
.eat_addr
+ (i
* 4) - adj
);
1725 if (eat_member
== 0)
1728 if (eat_member
- adj
<= datasize
)
1730 /* This rva is to a name (forwarding function) in our section. */
1731 /* Should locate a function descriptor. */
1733 "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1735 (long) (i
+ edt
.base
),
1736 (unsigned long) eat_member
,
1738 (int)(datasize
- (eat_member
- adj
)),
1739 data
+ eat_member
- adj
);
1743 /* Should locate a function descriptor in the reldata section. */
1745 "\t[%4ld] +base[%4ld] %04lx %s\n",
1747 (long) (i
+ edt
.base
),
1748 (unsigned long) eat_member
,
1753 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1754 /* Dump them in parallel for clarity. */
1756 _("\n[Ordinal/Name Pointer] Table\n"));
1758 /* PR 17512: Handle corrupt PE binaries. */
1759 if (edt
.npt_addr
+ (edt
.num_names
* 4) - adj
>= datasize
1760 /* PR 17512: file: bb68816e. */
1761 || edt
.num_names
* 4 < edt
.num_names
1762 || (data
+ edt
.npt_addr
- adj
) < data
)
1763 /* xgettext:c-format */
1764 fprintf (file
, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1765 (long) edt
.npt_addr
,
1766 (long) edt
.num_names
);
1767 /* PR 17512: file: 140-147171-0.004. */
1768 else if (edt
.ot_addr
+ (edt
.num_names
* 2) - adj
>= datasize
1769 || data
+ edt
.ot_addr
- adj
< data
)
1770 /* xgettext:c-format */
1771 fprintf (file
, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1773 (long) edt
.num_names
);
1774 else for (i
= 0; i
< edt
.num_names
; ++i
)
1779 ord
= bfd_get_16 (abfd
, data
+ edt
.ot_addr
+ (i
* 2) - adj
);
1780 name_ptr
= bfd_get_32 (abfd
, data
+ edt
.npt_addr
+ (i
* 4) - adj
);
1782 if ((name_ptr
- adj
) >= datasize
)
1784 /* xgettext:c-format */
1785 fprintf (file
, _("\t[%4ld] <corrupt offset: %lx>\n"),
1786 (long) ord
, (long) name_ptr
);
1790 char * name
= (char *) data
+ name_ptr
- adj
;
1792 fprintf (file
, "\t[%4ld] %.*s\n", (long) ord
,
1793 (int)((char *)(data
+ datasize
) - name
), name
);
1802 /* This really is architecture dependent. On IA-64, a .pdata entry
1803 consists of three dwords containing relative virtual addresses that
1804 specify the start and end address of the code range the entry
1805 covers and the address of the corresponding unwind info data.
1807 On ARM and SH-4, a compressed PDATA structure is used :
1808 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1809 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1810 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1812 This is the version for uncompressed data. */
1815 pe_print_pdata (bfd
* abfd
, void * vfile
)
1817 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
1818 # define PDATA_ROW_SIZE (3 * 8)
1820 # define PDATA_ROW_SIZE (5 * 4)
1822 FILE *file
= (FILE *) vfile
;
1824 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1825 bfd_size_type datasize
= 0;
1827 bfd_size_type start
, stop
;
1828 int onaline
= PDATA_ROW_SIZE
;
1831 || coff_section_data (abfd
, section
) == NULL
1832 || pei_section_data (abfd
, section
) == NULL
)
1835 stop
= pei_section_data (abfd
, section
)->virt_size
;
1836 if ((stop
% onaline
) != 0)
1838 /* xgettext:c-format */
1839 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
1840 (long) stop
, onaline
);
1843 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1844 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
1846 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1849 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1850 \t\tAddress Address Handler Data Address Mask\n"));
1853 datasize
= section
->size
;
1857 /* PR 17512: file: 002-193900-0.004. */
1858 if (datasize
< stop
)
1860 /* xgettext:c-format */
1861 fprintf (file
, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"),
1862 (long) stop
, (long) datasize
);
1866 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
1874 for (i
= start
; i
< stop
; i
+= onaline
)
1880 bfd_vma prolog_end_addr
;
1881 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64)
1885 if (i
+ PDATA_ROW_SIZE
> stop
)
1888 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
1889 end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
1890 eh_handler
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 8);
1891 eh_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 12);
1892 prolog_end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 16);
1894 if (begin_addr
== 0 && end_addr
== 0 && eh_handler
== 0
1895 && eh_data
== 0 && prolog_end_addr
== 0)
1896 /* We are probably into the padding of the section now. */
1899 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64)
1900 em_data
= ((eh_handler
& 0x1) << 2) | (prolog_end_addr
& 0x3);
1902 eh_handler
&= ~(bfd_vma
) 0x3;
1903 prolog_end_addr
&= ~(bfd_vma
) 0x3;
1906 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
1907 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
1908 bfd_fprintf_vma (abfd
, file
, end_addr
); fputc (' ', file
);
1909 bfd_fprintf_vma (abfd
, file
, eh_handler
);
1910 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64)
1912 bfd_fprintf_vma (abfd
, file
, eh_data
); fputc (' ', file
);
1913 bfd_fprintf_vma (abfd
, file
, prolog_end_addr
);
1914 fprintf (file
, " %x", em_data
);
1916 fprintf (file
, "\n");
1922 #undef PDATA_ROW_SIZE
1925 typedef struct sym_cache
1932 slurp_symtab (bfd
*abfd
, sym_cache
*psc
)
1934 asymbol
** sy
= NULL
;
1937 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1943 storage
= bfd_get_symtab_upper_bound (abfd
);
1948 sy
= (asymbol
**) bfd_malloc (storage
);
1953 psc
->symcount
= bfd_canonicalize_symtab (abfd
, sy
);
1954 if (psc
->symcount
< 0)
1960 my_symbol_for_address (bfd
*abfd
, bfd_vma func
, sym_cache
*psc
)
1965 psc
->syms
= slurp_symtab (abfd
, psc
);
1967 for (i
= 0; i
< psc
->symcount
; i
++)
1969 if (psc
->syms
[i
]->section
->vma
+ psc
->syms
[i
]->value
== func
)
1970 return psc
->syms
[i
]->name
;
1977 cleanup_syms (sym_cache
*psc
)
1984 /* This is the version for "compressed" pdata. */
1987 _bfd_XX_print_ce_compressed_pdata (bfd
* abfd
, void * vfile
)
1989 # define PDATA_ROW_SIZE (2 * 4)
1990 FILE *file
= (FILE *) vfile
;
1991 bfd_byte
*data
= NULL
;
1992 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1993 bfd_size_type datasize
= 0;
1995 bfd_size_type start
, stop
;
1996 int onaline
= PDATA_ROW_SIZE
;
1997 struct sym_cache cache
= {0, 0} ;
2000 || coff_section_data (abfd
, section
) == NULL
2001 || pei_section_data (abfd
, section
) == NULL
)
2004 stop
= pei_section_data (abfd
, section
)->virt_size
;
2005 if ((stop
% onaline
) != 0)
2007 /* xgettext:c-format */
2008 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
2009 (long) stop
, onaline
);
2012 _("\nThe Function Table (interpreted .pdata section contents)\n"));
2015 vma:\t\tBegin Prolog Function Flags Exception EH\n\
2016 \t\tAddress Length Length 32b exc Handler Data\n"));
2018 datasize
= section
->size
;
2022 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2029 if (stop
> datasize
)
2032 for (i
= start
; i
< stop
; i
+= onaline
)
2036 bfd_vma prolog_length
, function_length
;
2037 int flag32bit
, exception_flag
;
2040 if (i
+ PDATA_ROW_SIZE
> stop
)
2043 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
2044 other_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
2046 if (begin_addr
== 0 && other_data
== 0)
2047 /* We are probably into the padding of the section now. */
2050 prolog_length
= (other_data
& 0x000000FF);
2051 function_length
= (other_data
& 0x3FFFFF00) >> 8;
2052 flag32bit
= (int)((other_data
& 0x40000000) >> 30);
2053 exception_flag
= (int)((other_data
& 0x80000000) >> 31);
2056 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
2057 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
2058 bfd_fprintf_vma (abfd
, file
, prolog_length
); fputc (' ', file
);
2059 bfd_fprintf_vma (abfd
, file
, function_length
); fputc (' ', file
);
2060 fprintf (file
, "%2d %2d ", flag32bit
, exception_flag
);
2062 /* Get the exception handler's address and the data passed from the
2063 .text section. This is really the data that belongs with the .pdata
2064 but got "compressed" out for the ARM and SH4 architectures. */
2065 tsection
= bfd_get_section_by_name (abfd
, ".text");
2066 if (tsection
&& coff_section_data (abfd
, tsection
)
2067 && pei_section_data (abfd
, tsection
))
2069 bfd_vma eh_off
= (begin_addr
- 8) - tsection
->vma
;
2072 tdata
= (bfd_byte
*) bfd_malloc (8);
2075 if (bfd_get_section_contents (abfd
, tsection
, tdata
, eh_off
, 8))
2077 bfd_vma eh
, eh_data
;
2079 eh
= bfd_get_32 (abfd
, tdata
);
2080 eh_data
= bfd_get_32 (abfd
, tdata
+ 4);
2081 fprintf (file
, "%08x ", (unsigned int) eh
);
2082 fprintf (file
, "%08x", (unsigned int) eh_data
);
2085 const char *s
= my_symbol_for_address (abfd
, eh
, &cache
);
2088 fprintf (file
, " (%s) ", s
);
2095 fprintf (file
, "\n");
2100 cleanup_syms (& cache
);
2103 #undef PDATA_ROW_SIZE
2107 #define IMAGE_REL_BASED_HIGHADJ 4
2108 static const char * const tbl
[] =
2122 "UNKNOWN", /* MUST be last. */
2126 pe_print_reloc (bfd
* abfd
, void * vfile
)
2128 FILE *file
= (FILE *) vfile
;
2130 asection
*section
= bfd_get_section_by_name (abfd
, ".reloc");
2133 if (section
== NULL
|| section
->size
== 0 || !(section
->flags
& SEC_HAS_CONTENTS
))
2137 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2139 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2146 end
= data
+ section
->size
;
2147 while (p
+ 8 <= end
)
2150 bfd_vma virtual_address
;
2151 unsigned long number
, size
;
2152 bfd_byte
*chunk_end
;
2154 /* The .reloc section is a sequence of blocks, with a header consisting
2155 of two 32 bit quantities, followed by a number of 16 bit entries. */
2156 virtual_address
= bfd_get_32 (abfd
, p
);
2157 size
= bfd_get_32 (abfd
, p
+ 4);
2159 number
= (size
- 8) / 2;
2165 /* xgettext:c-format */
2166 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2167 (unsigned long) virtual_address
, size
, size
, number
);
2169 chunk_end
= p
- 8 + size
;
2170 if (chunk_end
> end
)
2173 while (p
+ 2 <= chunk_end
)
2175 unsigned short e
= bfd_get_16 (abfd
, p
);
2176 unsigned int t
= (e
& 0xF000) >> 12;
2177 int off
= e
& 0x0FFF;
2179 if (t
>= sizeof (tbl
) / sizeof (tbl
[0]))
2180 t
= (sizeof (tbl
) / sizeof (tbl
[0])) - 1;
2183 /* xgettext:c-format */
2184 _("\treloc %4d offset %4x [%4lx] %s"),
2185 j
, off
, (unsigned long) (off
+ virtual_address
), tbl
[t
]);
2190 /* HIGHADJ takes an argument, - the next record *is* the
2191 low 16 bits of addend. */
2192 if (t
== IMAGE_REL_BASED_HIGHADJ
&& p
+ 2 <= chunk_end
)
2194 fprintf (file
, " (%4x)", (unsigned int) bfd_get_16 (abfd
, p
));
2199 fprintf (file
, "\n");
2208 /* A data structure describing the regions of a .rsrc section.
2209 Some fields are filled in as the section is parsed. */
2211 typedef struct rsrc_regions
2213 bfd_byte
* section_start
;
2214 bfd_byte
* section_end
;
2215 bfd_byte
* strings_start
;
2216 bfd_byte
* resource_start
;
2220 rsrc_print_resource_directory (FILE * , bfd
*, unsigned int, bfd_byte
*,
2221 rsrc_regions
*, bfd_vma
);
2223 /* Print the resource entry at DATA, with the text indented by INDENT.
2224 Recusively calls rsrc_print_resource_directory to print the contents
2225 of directory entries.
2226 Returns the address of the end of the data associated with the entry
2227 or section_end + 1 upon failure. */
2230 rsrc_print_resource_entries (FILE *file
,
2232 unsigned int indent
,
2235 rsrc_regions
*regions
,
2238 unsigned long entry
, addr
, size
;
2241 if (data
+ 8 >= regions
->section_end
)
2242 return regions
->section_end
+ 1;
2244 /* xgettext:c-format */
2245 fprintf (file
, _("%03x %*.s Entry: "), (int)(data
- regions
->section_start
), indent
, " ");
2247 entry
= (unsigned long) bfd_get_32 (abfd
, data
);
2252 /* Note - the documentation says that this field is an RVA value
2253 but windres appears to produce a section relative offset with
2254 the top bit set. Support both styles for now. */
2255 if (HighBitSet (entry
))
2256 name
= regions
->section_start
+ WithoutHighBit (entry
);
2258 name
= regions
->section_start
+ entry
- rva_bias
;
2260 if (name
+ 2 < regions
->section_end
&& name
> regions
->section_start
)
2264 if (regions
->strings_start
== NULL
)
2265 regions
->strings_start
= name
;
2267 len
= bfd_get_16 (abfd
, name
);
2269 fprintf (file
, _("name: [val: %08lx len %d]: "), entry
, len
);
2271 if (name
+ 2 + len
* 2 < regions
->section_end
)
2273 /* This strange loop is to cope with multibyte characters. */
2280 /* Avoid printing control characters. */
2281 if (c
> 0 && c
< 32)
2282 fprintf (file
, "^%c", c
+ 64);
2284 fprintf (file
, "%.1s", name
);
2289 fprintf (file
, _("<corrupt string length: %#x>\n"), len
);
2290 /* PR binutils/17512: Do not try to continue decoding a
2291 corrupted resource section. It is likely to end up with
2292 reams of extraneous output. FIXME: We could probably
2293 continue if we disable the printing of strings... */
2294 return regions
->section_end
+ 1;
2299 fprintf (file
, _("<corrupt string offset: %#lx>\n"), entry
);
2300 return regions
->section_end
+ 1;
2304 fprintf (file
, _("ID: %#08lx"), entry
);
2306 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
2307 fprintf (file
, _(", Value: %#08lx\n"), entry
);
2309 if (HighBitSet (entry
))
2311 data
= regions
->section_start
+ WithoutHighBit (entry
);
2312 if (data
<= regions
->section_start
|| data
> regions
->section_end
)
2313 return regions
->section_end
+ 1;
2315 /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2316 in the resource table. We need some way to detect this. */
2317 return rsrc_print_resource_directory (file
, abfd
, indent
+ 1, data
,
2321 leaf
= regions
->section_start
+ entry
;
2323 if (leaf
+ 16 >= regions
->section_end
2324 /* PR 17512: file: 055dff7e. */
2325 || leaf
< regions
->section_start
)
2326 return regions
->section_end
+ 1;
2328 /* xgettext:c-format */
2329 fprintf (file
, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2330 (int) (entry
), indent
, " ",
2331 addr
= (long) bfd_get_32 (abfd
, leaf
),
2332 size
= (long) bfd_get_32 (abfd
, leaf
+ 4),
2333 (int) bfd_get_32 (abfd
, leaf
+ 8));
2335 /* Check that the reserved entry is 0. */
2336 if (bfd_get_32 (abfd
, leaf
+ 12) != 0
2337 /* And that the data address/size is valid too. */
2338 || (regions
->section_start
+ (addr
- rva_bias
) + size
> regions
->section_end
))
2339 return regions
->section_end
+ 1;
2341 if (regions
->resource_start
== NULL
)
2342 regions
->resource_start
= regions
->section_start
+ (addr
- rva_bias
);
2344 return regions
->section_start
+ (addr
- rva_bias
) + size
;
2347 #define max(a,b) ((a) > (b) ? (a) : (b))
2348 #define min(a,b) ((a) < (b) ? (a) : (b))
2351 rsrc_print_resource_directory (FILE * file
,
2353 unsigned int indent
,
2355 rsrc_regions
* regions
,
2358 unsigned int num_names
, num_ids
;
2359 bfd_byte
* highest_data
= data
;
2361 if (data
+ 16 >= regions
->section_end
)
2362 return regions
->section_end
+ 1;
2364 fprintf (file
, "%03x %*.s ", (int)(data
- regions
->section_start
), indent
, " ");
2367 case 0: fprintf (file
, "Type"); break;
2368 case 2: fprintf (file
, "Name"); break;
2369 case 4: fprintf (file
, "Language"); break;
2371 fprintf (file
, _("<unknown directory type: %d>\n"), indent
);
2372 /* FIXME: For now we end the printing here. If in the
2373 future more directory types are added to the RSRC spec
2374 then we will need to change this. */
2375 return regions
->section_end
+ 1;
2378 /* xgettext:c-format */
2379 fprintf (file
, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2380 (int) bfd_get_32 (abfd
, data
),
2381 (long) bfd_get_32 (abfd
, data
+ 4),
2382 (int) bfd_get_16 (abfd
, data
+ 8),
2383 (int) bfd_get_16 (abfd
, data
+ 10),
2384 num_names
= (int) bfd_get_16 (abfd
, data
+ 12),
2385 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14));
2388 while (num_names
--)
2390 bfd_byte
* entry_end
;
2392 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, true,
2393 data
, regions
, rva_bias
);
2395 highest_data
= max (highest_data
, entry_end
);
2396 if (entry_end
>= regions
->section_end
)
2402 bfd_byte
* entry_end
;
2404 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, false,
2405 data
, regions
, rva_bias
);
2407 highest_data
= max (highest_data
, entry_end
);
2408 if (entry_end
>= regions
->section_end
)
2412 return max (highest_data
, data
);
2415 /* Display the contents of a .rsrc section. We do not try to
2416 reproduce the resources, windres does that. Instead we dump
2417 the tables in a human readable format. */
2420 rsrc_print_section (bfd
* abfd
, void * vfile
)
2424 FILE * file
= (FILE *) vfile
;
2425 bfd_size_type datasize
;
2428 rsrc_regions regions
;
2430 pe
= pe_data (abfd
);
2434 section
= bfd_get_section_by_name (abfd
, ".rsrc");
2435 if (section
== NULL
)
2437 if (!(section
->flags
& SEC_HAS_CONTENTS
))
2440 datasize
= section
->size
;
2444 rva_bias
= section
->vma
- pe
->pe_opthdr
.ImageBase
;
2446 if (! bfd_malloc_and_get_section (abfd
, section
, & data
))
2452 regions
.section_start
= data
;
2453 regions
.section_end
= data
+ datasize
;
2454 regions
.strings_start
= NULL
;
2455 regions
.resource_start
= NULL
;
2458 fprintf (file
, "\nThe .rsrc Resource Directory section:\n");
2460 while (data
< regions
.section_end
)
2462 bfd_byte
* p
= data
;
2464 data
= rsrc_print_resource_directory (file
, abfd
, 0, data
, & regions
, rva_bias
);
2466 if (data
== regions
.section_end
+ 1)
2467 fprintf (file
, _("Corrupt .rsrc section detected!\n"));
2470 /* Align data before continuing. */
2471 int align
= (1 << section
->alignment_power
) - 1;
2473 data
= (bfd_byte
*) (((ptrdiff_t) (data
+ align
)) & ~ align
);
2474 rva_bias
+= data
- p
;
2476 /* For reasons that are unclear .rsrc sections are sometimes created
2477 aligned to a 1^3 boundary even when their alignment is set at
2478 1^2. Catch that case here before we issue a spurious warning
2480 if (data
== (regions
.section_end
- 4))
2481 data
= regions
.section_end
;
2482 else if (data
< regions
.section_end
)
2484 /* If the extra data is all zeros then do not complain.
2485 This is just padding so that the section meets the
2486 page size requirements. */
2487 while (++ data
< regions
.section_end
)
2490 if (data
< regions
.section_end
)
2491 fprintf (file
, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2496 if (regions
.strings_start
!= NULL
)
2497 fprintf (file
, _(" String table starts at offset: %#03x\n"),
2498 (int) (regions
.strings_start
- regions
.section_start
));
2499 if (regions
.resource_start
!= NULL
)
2500 fprintf (file
, _(" Resources start at offset: %#03x\n"),
2501 (int) (regions
.resource_start
- regions
.section_start
));
2503 free (regions
.section_start
);
2507 #define IMAGE_NUMBEROF_DEBUG_TYPES 17
2509 static char * debug_type_names
[IMAGE_NUMBEROF_DEBUG_TYPES
] =
2531 pe_print_debugdata (bfd
* abfd
, void * vfile
)
2533 FILE *file
= (FILE *) vfile
;
2534 pe_data_type
*pe
= pe_data (abfd
);
2535 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2538 bfd_size_type dataoff
;
2541 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2542 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2547 addr
+= extra
->ImageBase
;
2548 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2550 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2554 if (section
== NULL
)
2557 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2560 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
2563 _("\nThere is a debug directory in %s, but that section has no contents\n"),
2567 else if (section
->size
< size
)
2570 _("\nError: section %s contains the debug data starting address but it is too small\n"),
2575 fprintf (file
, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2576 section
->name
, (unsigned long) addr
);
2578 dataoff
= addr
- section
->vma
;
2580 if (size
> (section
->size
- dataoff
))
2582 fprintf (file
, _("The debug data size field in the data directory is too big for the section"));
2587 _("Type Size Rva Offset\n"));
2589 /* Read the whole section. */
2590 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2596 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2598 const char *type_name
;
2599 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2600 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2601 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2603 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2605 if ((idd
.Type
) >= IMAGE_NUMBEROF_DEBUG_TYPES
)
2606 type_name
= debug_type_names
[0];
2608 type_name
= debug_type_names
[idd
.Type
];
2610 fprintf (file
, " %2ld %14s %08lx %08lx %08lx\n",
2611 idd
.Type
, type_name
, idd
.SizeOfData
,
2612 idd
.AddressOfRawData
, idd
.PointerToRawData
);
2614 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_CODEVIEW
)
2616 char signature
[CV_INFO_SIGNATURE_LENGTH
* 2 + 1];
2617 /* PR 17512: file: 065-29434-0.001:0.1
2618 We need to use a 32-bit aligned buffer
2619 to safely read in a codeview record. */
2620 char buffer
[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO
);
2623 CODEVIEW_INFO
*cvinfo
= (CODEVIEW_INFO
*) buffer
;
2625 /* The debug entry doesn't have to have to be in a section,
2626 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2627 if (!_bfd_XXi_slurp_codeview_record (abfd
, (file_ptr
) idd
.PointerToRawData
,
2628 idd
.SizeOfData
, cvinfo
, &pdb
))
2631 for (j
= 0; j
< cvinfo
->SignatureLength
; j
++)
2632 sprintf (&signature
[j
*2], "%02x", cvinfo
->Signature
[j
] & 0xff);
2634 /* xgettext:c-format */
2635 fprintf (file
, _("(format %c%c%c%c signature %s age %ld pdb %s)\n"),
2636 buffer
[0], buffer
[1], buffer
[2], buffer
[3],
2637 signature
, cvinfo
->Age
, pdb
[0] ? pdb
: "(none)");
2645 if (size
% sizeof (struct external_IMAGE_DEBUG_DIRECTORY
) != 0)
2647 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2653 pe_is_repro (bfd
* abfd
)
2655 pe_data_type
*pe
= pe_data (abfd
);
2656 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2659 bfd_size_type dataoff
;
2663 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2664 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2669 addr
+= extra
->ImageBase
;
2670 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2672 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2676 if ((section
== NULL
)
2677 || (!(section
->flags
& SEC_HAS_CONTENTS
))
2678 || (section
->size
< size
))
2683 dataoff
= addr
- section
->vma
;
2685 if (size
> (section
->size
- dataoff
))
2690 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2696 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2698 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2699 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2700 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2702 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2704 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_REPRO
)
2716 /* Print out the program headers. */
2719 _bfd_XX_print_private_bfd_data_common (bfd
* abfd
, void * vfile
)
2721 FILE *file
= (FILE *) vfile
;
2723 pe_data_type
*pe
= pe_data (abfd
);
2724 struct internal_extra_pe_aouthdr
*i
= &pe
->pe_opthdr
;
2725 const char *subsystem_name
= NULL
;
2728 /* The MS dumpbin program reportedly ands with 0xff0f before
2729 printing the characteristics field. Not sure why. No reason to
2731 fprintf (file
, _("\nCharacteristics 0x%x\n"), pe
->real_flags
);
2733 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2734 PF (IMAGE_FILE_RELOCS_STRIPPED
, "relocations stripped");
2735 PF (IMAGE_FILE_EXECUTABLE_IMAGE
, "executable");
2736 PF (IMAGE_FILE_LINE_NUMS_STRIPPED
, "line numbers stripped");
2737 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED
, "symbols stripped");
2738 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE
, "large address aware");
2739 PF (IMAGE_FILE_BYTES_REVERSED_LO
, "little endian");
2740 PF (IMAGE_FILE_32BIT_MACHINE
, "32 bit words");
2741 PF (IMAGE_FILE_DEBUG_STRIPPED
, "debugging information removed");
2742 PF (IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP
, "copy to swap file if on removable media");
2743 PF (IMAGE_FILE_NET_RUN_FROM_SWAP
, "copy to swap file if on network media");
2744 PF (IMAGE_FILE_SYSTEM
, "system file");
2745 PF (IMAGE_FILE_DLL
, "DLL");
2746 PF (IMAGE_FILE_UP_SYSTEM_ONLY
, "run only on uniprocessor machine");
2747 PF (IMAGE_FILE_BYTES_REVERSED_HI
, "big endian");
2751 If a PE_IMAGE_DEBUG_TYPE_REPRO entry is present in the debug directory, the
2752 timestamp is to be interpreted as the hash of a reproducible build.
2754 if (pe_is_repro (abfd
))
2756 fprintf (file
, "\nTime/Date\t\t%08lx", pe
->coff
.timestamp
);
2757 fprintf (file
, "\t(This is a reproducible build file hash, not a timestamp)\n");
2761 /* ctime implies '\n'. */
2762 time_t t
= pe
->coff
.timestamp
;
2763 fprintf (file
, "\nTime/Date\t\t%s", ctime (&t
));
2766 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2767 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2769 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2770 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2772 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2773 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2778 case IMAGE_NT_OPTIONAL_HDR_MAGIC
:
2781 case IMAGE_NT_OPTIONAL_HDR64_MAGIC
:
2784 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC
:
2791 fprintf (file
, "Magic\t\t\t%04x", i
->Magic
);
2793 fprintf (file
, "\t(%s)",name
);
2794 fprintf (file
, "\nMajorLinkerVersion\t%d\n", i
->MajorLinkerVersion
);
2795 fprintf (file
, "MinorLinkerVersion\t%d\n", i
->MinorLinkerVersion
);
2796 fprintf (file
, "SizeOfCode\t\t");
2797 bfd_fprintf_vma (abfd
, file
, i
->SizeOfCode
);
2798 fprintf (file
, "\nSizeOfInitializedData\t");
2799 bfd_fprintf_vma (abfd
, file
, i
->SizeOfInitializedData
);
2800 fprintf (file
, "\nSizeOfUninitializedData\t");
2801 bfd_fprintf_vma (abfd
, file
, i
->SizeOfUninitializedData
);
2802 fprintf (file
, "\nAddressOfEntryPoint\t");
2803 bfd_fprintf_vma (abfd
, file
, i
->AddressOfEntryPoint
);
2804 fprintf (file
, "\nBaseOfCode\t\t");
2805 bfd_fprintf_vma (abfd
, file
, i
->BaseOfCode
);
2806 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
2807 /* PE32+ does not have BaseOfData member! */
2808 fprintf (file
, "\nBaseOfData\t\t");
2809 bfd_fprintf_vma (abfd
, file
, i
->BaseOfData
);
2812 fprintf (file
, "\nImageBase\t\t");
2813 bfd_fprintf_vma (abfd
, file
, i
->ImageBase
);
2814 fprintf (file
, "\nSectionAlignment\t%08x\n", i
->SectionAlignment
);
2815 fprintf (file
, "FileAlignment\t\t%08x\n", i
->FileAlignment
);
2816 fprintf (file
, "MajorOSystemVersion\t%d\n", i
->MajorOperatingSystemVersion
);
2817 fprintf (file
, "MinorOSystemVersion\t%d\n", i
->MinorOperatingSystemVersion
);
2818 fprintf (file
, "MajorImageVersion\t%d\n", i
->MajorImageVersion
);
2819 fprintf (file
, "MinorImageVersion\t%d\n", i
->MinorImageVersion
);
2820 fprintf (file
, "MajorSubsystemVersion\t%d\n", i
->MajorSubsystemVersion
);
2821 fprintf (file
, "MinorSubsystemVersion\t%d\n", i
->MinorSubsystemVersion
);
2822 fprintf (file
, "Win32Version\t\t%08x\n", i
->Reserved1
);
2823 fprintf (file
, "SizeOfImage\t\t%08x\n", i
->SizeOfImage
);
2824 fprintf (file
, "SizeOfHeaders\t\t%08x\n", i
->SizeOfHeaders
);
2825 fprintf (file
, "CheckSum\t\t%08x\n", i
->CheckSum
);
2827 switch (i
->Subsystem
)
2829 case IMAGE_SUBSYSTEM_UNKNOWN
:
2830 subsystem_name
= "unspecified";
2832 case IMAGE_SUBSYSTEM_NATIVE
:
2833 subsystem_name
= "NT native";
2835 case IMAGE_SUBSYSTEM_WINDOWS_GUI
:
2836 subsystem_name
= "Windows GUI";
2838 case IMAGE_SUBSYSTEM_WINDOWS_CUI
:
2839 subsystem_name
= "Windows CUI";
2841 case IMAGE_SUBSYSTEM_POSIX_CUI
:
2842 subsystem_name
= "POSIX CUI";
2844 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI
:
2845 subsystem_name
= "Wince CUI";
2847 /* These are from UEFI Platform Initialization Specification 1.1. */
2848 case IMAGE_SUBSYSTEM_EFI_APPLICATION
:
2849 subsystem_name
= "EFI application";
2851 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
:
2852 subsystem_name
= "EFI boot service driver";
2854 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
:
2855 subsystem_name
= "EFI runtime driver";
2857 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER
:
2858 subsystem_name
= "SAL runtime driver";
2860 /* This is from revision 8.0 of the MS PE/COFF spec */
2861 case IMAGE_SUBSYSTEM_XBOX
:
2862 subsystem_name
= "XBOX";
2864 /* Added default case for clarity - subsystem_name is NULL anyway. */
2866 subsystem_name
= NULL
;
2869 fprintf (file
, "Subsystem\t\t%08x", i
->Subsystem
);
2871 fprintf (file
, "\t(%s)", subsystem_name
);
2872 fprintf (file
, "\nDllCharacteristics\t%08x\n", i
->DllCharacteristics
);
2873 if (i
->DllCharacteristics
)
2875 unsigned short dllch
= i
->DllCharacteristics
;
2876 const char *indent
= "\t\t\t\t\t";
2878 if (dllch
& IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA
)
2879 fprintf (file
, "%sHIGH_ENTROPY_VA\n", indent
);
2880 if (dllch
& IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE
)
2881 fprintf (file
, "%sDYNAMIC_BASE\n", indent
);
2882 if (dllch
& IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY
)
2883 fprintf (file
, "%sFORCE_INTEGRITY\n", indent
);
2884 if (dllch
& IMAGE_DLL_CHARACTERISTICS_NX_COMPAT
)
2885 fprintf (file
, "%sNX_COMPAT\n", indent
);
2886 if (dllch
& IMAGE_DLLCHARACTERISTICS_NO_ISOLATION
)
2887 fprintf (file
, "%sNO_ISOLATION\n", indent
);
2888 if (dllch
& IMAGE_DLLCHARACTERISTICS_NO_SEH
)
2889 fprintf (file
, "%sNO_SEH\n", indent
);
2890 if (dllch
& IMAGE_DLLCHARACTERISTICS_NO_BIND
)
2891 fprintf (file
, "%sNO_BIND\n", indent
);
2892 if (dllch
& IMAGE_DLLCHARACTERISTICS_APPCONTAINER
)
2893 fprintf (file
, "%sAPPCONTAINER\n", indent
);
2894 if (dllch
& IMAGE_DLLCHARACTERISTICS_WDM_DRIVER
)
2895 fprintf (file
, "%sWDM_DRIVER\n", indent
);
2896 if (dllch
& IMAGE_DLLCHARACTERISTICS_GUARD_CF
)
2897 fprintf (file
, "%sGUARD_CF\n", indent
);
2898 if (dllch
& IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE
)
2899 fprintf (file
, "%sTERMINAL_SERVICE_AWARE\n", indent
);
2901 fprintf (file
, "SizeOfStackReserve\t");
2902 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackReserve
);
2903 fprintf (file
, "\nSizeOfStackCommit\t");
2904 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackCommit
);
2905 fprintf (file
, "\nSizeOfHeapReserve\t");
2906 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapReserve
);
2907 fprintf (file
, "\nSizeOfHeapCommit\t");
2908 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapCommit
);
2909 fprintf (file
, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i
->LoaderFlags
);
2910 fprintf (file
, "NumberOfRvaAndSizes\t%08lx\n",
2911 (unsigned long) i
->NumberOfRvaAndSizes
);
2913 fprintf (file
, "\nThe Data Directory\n");
2914 for (j
= 0; j
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; j
++)
2916 fprintf (file
, "Entry %1x ", j
);
2917 bfd_fprintf_vma (abfd
, file
, i
->DataDirectory
[j
].VirtualAddress
);
2918 fprintf (file
, " %08lx ", (unsigned long) i
->DataDirectory
[j
].Size
);
2919 fprintf (file
, "%s\n", dir_names
[j
]);
2922 pe_print_idata (abfd
, vfile
);
2923 pe_print_edata (abfd
, vfile
);
2924 if (bfd_coff_have_print_pdata (abfd
))
2925 bfd_coff_print_pdata (abfd
, vfile
);
2927 pe_print_pdata (abfd
, vfile
);
2928 pe_print_reloc (abfd
, vfile
);
2929 pe_print_debugdata (abfd
, file
);
2931 rsrc_print_section (abfd
, vfile
);
2937 is_vma_in_section (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sect
, void *obj
)
2939 bfd_vma addr
= * (bfd_vma
*) obj
;
2940 return (addr
>= sect
->vma
) && (addr
< (sect
->vma
+ sect
->size
));
2944 find_section_by_vma (bfd
*abfd
, bfd_vma addr
)
2946 return bfd_sections_find_if (abfd
, is_vma_in_section
, (void *) & addr
);
2949 /* Copy any private info we understand from the input bfd
2950 to the output bfd. */
2953 _bfd_XX_bfd_copy_private_bfd_data_common (bfd
* ibfd
, bfd
* obfd
)
2955 pe_data_type
*ipe
, *ope
;
2958 /* One day we may try to grok other private data. */
2959 if (ibfd
->xvec
->flavour
!= bfd_target_coff_flavour
2960 || obfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
2963 ipe
= pe_data (ibfd
);
2964 ope
= pe_data (obfd
);
2966 /* pe_opthdr is copied in copy_object. */
2967 ope
->dll
= ipe
->dll
;
2969 /* Don't copy input subsystem if output is different from input. */
2970 if (obfd
->xvec
!= ibfd
->xvec
)
2971 ope
->pe_opthdr
.Subsystem
= IMAGE_SUBSYSTEM_UNKNOWN
;
2973 /* For strip: if we removed .reloc, we'll make a real mess of things
2974 if we don't remove this entry as well. */
2975 if (! pe_data (obfd
)->has_reloc_section
)
2977 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].VirtualAddress
= 0;
2978 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].Size
= 0;
2981 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2982 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2984 if (! pe_data (ibfd
)->has_reloc_section
2985 && ! (pe_data (ibfd
)->real_flags
& IMAGE_FILE_RELOCS_STRIPPED
))
2986 pe_data (obfd
)->dont_strip_reloc
= 1;
2988 memcpy (ope
->dos_message
, ipe
->dos_message
, sizeof (ope
->dos_message
));
2990 /* The file offsets contained in the debug directory need rewriting. */
2991 size
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
;
2994 bfd_vma addr
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
2995 + ope
->pe_opthdr
.ImageBase
;
2996 /* In particular a .buildid section may overlap (in VA space) with
2997 whatever section comes ahead of it (largely because of section->size
2998 representing s_size, not virt_size). Therefore don't look for the
2999 section containing the first byte, but for that covering the last
3001 bfd_vma last
= addr
+ size
- 1;
3002 asection
*section
= find_section_by_vma (obfd
, last
);
3004 if (section
!= NULL
)
3007 bfd_vma dataoff
= addr
- section
->vma
;
3009 /* PR 17512: file: 0f15796a. */
3010 if (addr
< section
->vma
3011 || section
->size
< dataoff
3012 || section
->size
- dataoff
< size
)
3014 /* xgettext:c-format */
3016 (_("%pB: Data Directory (%lx bytes at %" PRIx64
") "
3017 "extends across section boundary at %" PRIx64
),
3018 obfd
, ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
,
3019 (uint64_t) addr
, (uint64_t) section
->vma
);
3023 if (bfd_malloc_and_get_section (obfd
, section
, &data
))
3026 struct external_IMAGE_DEBUG_DIRECTORY
*dd
=
3027 (struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
);
3029 for (i
= 0; i
< ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
3030 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
3032 asection
*ddsection
;
3033 struct external_IMAGE_DEBUG_DIRECTORY
*edd
= &(dd
[i
]);
3034 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
3037 _bfd_XXi_swap_debugdir_in (obfd
, edd
, &idd
);
3039 /* RVA 0 means only offset is valid, not handled yet. */
3040 if (idd
.AddressOfRawData
== 0)
3043 idd_vma
= idd
.AddressOfRawData
+ ope
->pe_opthdr
.ImageBase
;
3044 ddsection
= find_section_by_vma (obfd
, idd_vma
);
3046 continue; /* Not in a section! */
3048 idd
.PointerToRawData
3049 = ddsection
->filepos
+ idd_vma
- ddsection
->vma
;
3050 _bfd_XXi_swap_debugdir_out (obfd
, &idd
, edd
);
3053 if (!bfd_set_section_contents (obfd
, section
, data
, 0,
3056 _bfd_error_handler (_("failed to update file offsets"
3057 " in debug directory"));
3065 _bfd_error_handler (_("%pB: failed to read "
3066 "debug data section"), obfd
);
3075 /* Copy private section data. */
3078 _bfd_XX_bfd_copy_private_section_data (bfd
*ibfd
,
3083 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
3084 || bfd_get_flavour (obfd
) != bfd_target_coff_flavour
)
3087 if (coff_section_data (ibfd
, isec
) != NULL
3088 && pei_section_data (ibfd
, isec
) != NULL
)
3090 if (coff_section_data (obfd
, osec
) == NULL
)
3092 size_t amt
= sizeof (struct coff_section_tdata
);
3093 osec
->used_by_bfd
= bfd_zalloc (obfd
, amt
);
3094 if (osec
->used_by_bfd
== NULL
)
3098 if (pei_section_data (obfd
, osec
) == NULL
)
3100 size_t amt
= sizeof (struct pei_section_tdata
);
3101 coff_section_data (obfd
, osec
)->tdata
= bfd_zalloc (obfd
, amt
);
3102 if (coff_section_data (obfd
, osec
)->tdata
== NULL
)
3106 pei_section_data (obfd
, osec
)->virt_size
=
3107 pei_section_data (ibfd
, isec
)->virt_size
;
3108 pei_section_data (obfd
, osec
)->pe_flags
=
3109 pei_section_data (ibfd
, isec
)->pe_flags
;
3116 _bfd_XX_get_symbol_info (bfd
* abfd
, asymbol
*symbol
, symbol_info
*ret
)
3118 coff_get_symbol_info (abfd
, symbol
, ret
);
3121 #if !defined(COFF_WITH_pep) && (defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64))
3123 sort_x64_pdata (const void *l
, const void *r
)
3125 const char *lp
= (const char *) l
;
3126 const char *rp
= (const char *) r
;
3128 vl
= bfd_getl32 (lp
); vr
= bfd_getl32 (rp
);
3130 return (vl
< vr
? -1 : 1);
3131 /* We compare just begin address. */
3136 /* Functions to process a .rsrc section. */
3138 static unsigned int sizeof_leaves
;
3139 static unsigned int sizeof_strings
;
3140 static unsigned int sizeof_tables_and_entries
;
3143 rsrc_count_directory (bfd
*, bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
3146 rsrc_count_entries (bfd
*abfd
,
3148 bfd_byte
*datastart
,
3153 unsigned long entry
, addr
, size
;
3155 if (data
+ 8 >= dataend
)
3162 entry
= (long) bfd_get_32 (abfd
, data
);
3164 if (HighBitSet (entry
))
3165 name
= datastart
+ WithoutHighBit (entry
);
3167 name
= datastart
+ entry
- rva_bias
;
3169 if (name
+ 2 >= dataend
|| name
< datastart
)
3172 unsigned int len
= bfd_get_16 (abfd
, name
);
3173 if (len
== 0 || len
> 256)
3177 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
3179 if (HighBitSet (entry
))
3181 data
= datastart
+ WithoutHighBit (entry
);
3183 if (data
<= datastart
|| data
>= dataend
)
3186 return rsrc_count_directory (abfd
, datastart
, data
, dataend
, rva_bias
);
3189 if (datastart
+ entry
+ 16 >= dataend
)
3192 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
);
3193 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4);
3195 return datastart
+ addr
- rva_bias
+ size
;
3199 rsrc_count_directory (bfd
* abfd
,
3200 bfd_byte
* datastart
,
3205 unsigned int num_entries
, num_ids
;
3206 bfd_byte
* highest_data
= data
;
3208 if (data
+ 16 >= dataend
)
3211 num_entries
= (int) bfd_get_16 (abfd
, data
+ 12);
3212 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14);
3214 num_entries
+= num_ids
;
3218 while (num_entries
--)
3220 bfd_byte
* entry_end
;
3222 entry_end
= rsrc_count_entries (abfd
, num_entries
>= num_ids
,
3223 datastart
, data
, dataend
, rva_bias
);
3225 highest_data
= max (highest_data
, entry_end
);
3226 if (entry_end
>= dataend
)
3230 return max (highest_data
, data
);
3233 typedef struct rsrc_dir_chain
3235 unsigned int num_entries
;
3236 struct rsrc_entry
* first_entry
;
3237 struct rsrc_entry
* last_entry
;
3240 typedef struct rsrc_directory
3242 unsigned int characteristics
;
3247 rsrc_dir_chain names
;
3250 struct rsrc_entry
* entry
;
3253 typedef struct rsrc_string
3259 typedef struct rsrc_leaf
3262 unsigned int codepage
;
3266 typedef struct rsrc_entry
3272 struct rsrc_string name
;
3278 struct rsrc_directory
* directory
;
3279 struct rsrc_leaf
* leaf
;
3282 struct rsrc_entry
* next_entry
;
3283 struct rsrc_directory
* parent
;
3287 rsrc_parse_directory (bfd
*, rsrc_directory
*, bfd_byte
*,
3288 bfd_byte
*, bfd_byte
*, bfd_vma
, rsrc_entry
*);
3291 rsrc_parse_entry (bfd
*abfd
,
3294 bfd_byte
*datastart
,
3298 rsrc_directory
*parent
)
3300 unsigned long val
, addr
, size
;
3302 val
= bfd_get_32 (abfd
, data
);
3304 entry
->parent
= parent
;
3305 entry
->is_name
= is_name
;
3311 if (HighBitSet (val
))
3313 val
= WithoutHighBit (val
);
3315 address
= datastart
+ val
;
3319 address
= datastart
+ val
- rva_bias
;
3322 if (address
+ 3 > dataend
)
3325 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, address
);
3326 entry
->name_id
.name
.string
= address
+ 2;
3329 entry
->name_id
.id
= val
;
3331 val
= bfd_get_32 (abfd
, data
+ 4);
3333 if (HighBitSet (val
))
3335 entry
->is_dir
= true;
3336 entry
->value
.directory
= bfd_malloc (sizeof * entry
->value
.directory
);
3337 if (entry
->value
.directory
== NULL
)
3340 return rsrc_parse_directory (abfd
, entry
->value
.directory
,
3342 datastart
+ WithoutHighBit (val
),
3343 dataend
, rva_bias
, entry
);
3346 entry
->is_dir
= false;
3347 entry
->value
.leaf
= bfd_malloc (sizeof * entry
->value
.leaf
);
3348 if (entry
->value
.leaf
== NULL
)
3351 data
= datastart
+ val
;
3352 if (data
< datastart
|| data
>= dataend
)
3355 addr
= bfd_get_32 (abfd
, data
);
3356 size
= entry
->value
.leaf
->size
= bfd_get_32 (abfd
, data
+ 4);
3357 entry
->value
.leaf
->codepage
= bfd_get_32 (abfd
, data
+ 8);
3358 /* FIXME: We assume that the reserved field (data + 12) is OK. */
3360 entry
->value
.leaf
->data
= bfd_malloc (size
);
3361 if (entry
->value
.leaf
->data
== NULL
)
3364 memcpy (entry
->value
.leaf
->data
, datastart
+ addr
- rva_bias
, size
);
3365 return datastart
+ (addr
- rva_bias
) + size
;
3369 rsrc_parse_entries (bfd
*abfd
,
3370 rsrc_dir_chain
*chain
,
3372 bfd_byte
*highest_data
,
3373 bfd_byte
*datastart
,
3377 rsrc_directory
*parent
)
3382 if (chain
->num_entries
== 0)
3384 chain
->first_entry
= chain
->last_entry
= NULL
;
3385 return highest_data
;
3388 entry
= bfd_malloc (sizeof * entry
);
3392 chain
->first_entry
= entry
;
3394 for (i
= chain
->num_entries
; i
--;)
3396 bfd_byte
* entry_end
;
3398 entry_end
= rsrc_parse_entry (abfd
, is_name
, entry
, datastart
,
3399 data
, dataend
, rva_bias
, parent
);
3401 highest_data
= max (entry_end
, highest_data
);
3402 if (entry_end
> dataend
)
3407 entry
->next_entry
= bfd_malloc (sizeof * entry
);
3408 entry
= entry
->next_entry
;
3413 entry
->next_entry
= NULL
;
3416 chain
->last_entry
= entry
;
3418 return highest_data
;
3422 rsrc_parse_directory (bfd
* abfd
,
3423 rsrc_directory
* table
,
3424 bfd_byte
* datastart
,
3430 bfd_byte
* highest_data
= data
;
3435 table
->characteristics
= bfd_get_32 (abfd
, data
);
3436 table
->time
= bfd_get_32 (abfd
, data
+ 4);
3437 table
->major
= bfd_get_16 (abfd
, data
+ 8);
3438 table
->minor
= bfd_get_16 (abfd
, data
+ 10);
3439 table
->names
.num_entries
= bfd_get_16 (abfd
, data
+ 12);
3440 table
->ids
.num_entries
= bfd_get_16 (abfd
, data
+ 14);
3441 table
->entry
= entry
;
3445 highest_data
= rsrc_parse_entries (abfd
, & table
->names
, true, data
,
3446 datastart
, data
, dataend
, rva_bias
, table
);
3447 data
+= table
->names
.num_entries
* 8;
3449 highest_data
= rsrc_parse_entries (abfd
, & table
->ids
, false, highest_data
,
3450 datastart
, data
, dataend
, rva_bias
, table
);
3451 data
+= table
->ids
.num_entries
* 8;
3453 return max (highest_data
, data
);
3456 typedef struct rsrc_write_data
3459 bfd_byte
* datastart
;
3460 bfd_byte
* next_table
;
3461 bfd_byte
* next_leaf
;
3462 bfd_byte
* next_string
;
3463 bfd_byte
* next_data
;
3468 rsrc_write_string (rsrc_write_data
* data
,
3469 rsrc_string
* string
)
3471 bfd_put_16 (data
->abfd
, string
->len
, data
->next_string
);
3472 memcpy (data
->next_string
+ 2, string
->string
, string
->len
* 2);
3473 data
->next_string
+= (string
->len
+ 1) * 2;
3476 static inline unsigned int
3477 rsrc_compute_rva (rsrc_write_data
* data
,
3480 return (addr
- data
->datastart
) + data
->rva_bias
;
3484 rsrc_write_leaf (rsrc_write_data
* data
,
3487 bfd_put_32 (data
->abfd
, rsrc_compute_rva (data
, data
->next_data
),
3489 bfd_put_32 (data
->abfd
, leaf
->size
, data
->next_leaf
+ 4);
3490 bfd_put_32 (data
->abfd
, leaf
->codepage
, data
->next_leaf
+ 8);
3491 bfd_put_32 (data
->abfd
, 0 /*reserved*/, data
->next_leaf
+ 12);
3492 data
->next_leaf
+= 16;
3494 memcpy (data
->next_data
, leaf
->data
, leaf
->size
);
3495 /* An undocumented feature of Windows resources is that each unit
3496 of raw data is 8-byte aligned... */
3497 data
->next_data
+= ((leaf
->size
+ 7) & ~7);
3500 static void rsrc_write_directory (rsrc_write_data
*, rsrc_directory
*);
3503 rsrc_write_entry (rsrc_write_data
* data
,
3509 bfd_put_32 (data
->abfd
,
3510 SetHighBit (data
->next_string
- data
->datastart
),
3512 rsrc_write_string (data
, & entry
->name_id
.name
);
3515 bfd_put_32 (data
->abfd
, entry
->name_id
.id
, where
);
3519 bfd_put_32 (data
->abfd
,
3520 SetHighBit (data
->next_table
- data
->datastart
),
3522 rsrc_write_directory (data
, entry
->value
.directory
);
3526 bfd_put_32 (data
->abfd
, data
->next_leaf
- data
->datastart
, where
+ 4);
3527 rsrc_write_leaf (data
, entry
->value
.leaf
);
3532 rsrc_compute_region_sizes (rsrc_directory
* dir
)
3534 struct rsrc_entry
* entry
;
3539 sizeof_tables_and_entries
+= 16;
3541 for (entry
= dir
->names
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3543 sizeof_tables_and_entries
+= 8;
3545 sizeof_strings
+= (entry
->name_id
.name
.len
+ 1) * 2;
3548 rsrc_compute_region_sizes (entry
->value
.directory
);
3550 sizeof_leaves
+= 16;
3553 for (entry
= dir
->ids
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3555 sizeof_tables_and_entries
+= 8;
3558 rsrc_compute_region_sizes (entry
->value
.directory
);
3560 sizeof_leaves
+= 16;
3565 rsrc_write_directory (rsrc_write_data
* data
,
3566 rsrc_directory
* dir
)
3570 bfd_byte
* next_entry
;
3573 bfd_put_32 (data
->abfd
, dir
->characteristics
, data
->next_table
);
3574 bfd_put_32 (data
->abfd
, 0 /*dir->time*/, data
->next_table
+ 4);
3575 bfd_put_16 (data
->abfd
, dir
->major
, data
->next_table
+ 8);
3576 bfd_put_16 (data
->abfd
, dir
->minor
, data
->next_table
+ 10);
3577 bfd_put_16 (data
->abfd
, dir
->names
.num_entries
, data
->next_table
+ 12);
3578 bfd_put_16 (data
->abfd
, dir
->ids
.num_entries
, data
->next_table
+ 14);
3580 /* Compute where the entries and the next table will be placed. */
3581 next_entry
= data
->next_table
+ 16;
3582 data
->next_table
= next_entry
+ (dir
->names
.num_entries
* 8)
3583 + (dir
->ids
.num_entries
* 8);
3584 nt
= data
->next_table
;
3586 /* Write the entries. */
3587 for (i
= dir
->names
.num_entries
, entry
= dir
->names
.first_entry
;
3588 i
> 0 && entry
!= NULL
;
3589 i
--, entry
= entry
->next_entry
)
3591 BFD_ASSERT (entry
->is_name
);
3592 rsrc_write_entry (data
, next_entry
, entry
);
3595 BFD_ASSERT (i
== 0);
3596 BFD_ASSERT (entry
== NULL
);
3598 for (i
= dir
->ids
.num_entries
, entry
= dir
->ids
.first_entry
;
3599 i
> 0 && entry
!= NULL
;
3600 i
--, entry
= entry
->next_entry
)
3602 BFD_ASSERT (! entry
->is_name
);
3603 rsrc_write_entry (data
, next_entry
, entry
);
3606 BFD_ASSERT (i
== 0);
3607 BFD_ASSERT (entry
== NULL
);
3608 BFD_ASSERT (nt
== next_entry
);
3611 #if ! defined __CYGWIN__ && ! defined __MINGW32__
3612 /* Return the length (number of units) of the first character in S,
3613 putting its 'ucs4_t' representation in *PUC. */
3616 u16_mbtouc (wint_t * puc
, const unsigned short * s
, unsigned int n
)
3618 unsigned short c
= * s
;
3620 if (c
< 0xd800 || c
>= 0xe000)
3630 if (s
[1] >= 0xdc00 && s
[1] < 0xe000)
3632 *puc
= 0x10000 + ((c
- 0xd800) << 10) + (s
[1] - 0xdc00);
3638 /* Incomplete multibyte character. */
3644 /* Invalid multibyte character. */
3648 #endif /* not Cygwin/Mingw */
3650 /* Perform a comparison of two entries. */
3652 rsrc_cmp (bool is_name
, rsrc_entry
* a
, rsrc_entry
* b
)
3661 return a
->name_id
.id
- b
->name_id
.id
;
3663 /* We have to perform a case insenstive, unicode string comparison... */
3664 astring
= a
->name_id
.name
.string
;
3665 alen
= a
->name_id
.name
.len
;
3666 bstring
= b
->name_id
.name
.string
;
3667 blen
= b
->name_id
.name
.len
;
3669 #if defined __CYGWIN__ || defined __MINGW32__
3670 /* Under Windows hosts (both Cygwin and Mingw types),
3671 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3672 function however goes by different names in the two environments... */
3676 #define rscpcmp wcsncasecmp
3679 #define rscpcmp wcsnicmp
3682 res
= rscpcmp ((const wchar_t *) astring
, (const wchar_t *) bstring
,
3690 for (i
= min (alen
, blen
); i
--; astring
+= 2, bstring
+= 2)
3695 /* Convert UTF-16 unicode characters into wchar_t characters
3696 so that we can then perform a case insensitive comparison. */
3697 unsigned int Alen
= u16_mbtouc (& awc
, (const unsigned short *) astring
, 2);
3698 unsigned int Blen
= u16_mbtouc (& bwc
, (const unsigned short *) bstring
, 2);
3703 awc
= towlower (awc
);
3704 bwc
= towlower (bwc
);
3720 rsrc_print_name (char * buffer
, rsrc_string string
)
3723 bfd_byte
* name
= string
.string
;
3725 for (i
= string
.len
; i
--; name
+= 2)
3726 sprintf (buffer
+ strlen (buffer
), "%.1s", name
);
3730 rsrc_resource_name (rsrc_entry
*entry
, rsrc_directory
*dir
, char *buffer
)
3732 bool is_string
= false;
3736 if (dir
!= NULL
&& dir
->entry
!= NULL
&& dir
->entry
->parent
!= NULL
3737 && dir
->entry
->parent
->entry
!= NULL
)
3739 strcpy (buffer
, "type: ");
3740 if (dir
->entry
->parent
->entry
->is_name
)
3741 rsrc_print_name (buffer
+ strlen (buffer
),
3742 dir
->entry
->parent
->entry
->name_id
.name
);
3745 unsigned int id
= dir
->entry
->parent
->entry
->name_id
.id
;
3747 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3750 case 1: strcat (buffer
, " (CURSOR)"); break;
3751 case 2: strcat (buffer
, " (BITMAP)"); break;
3752 case 3: strcat (buffer
, " (ICON)"); break;
3753 case 4: strcat (buffer
, " (MENU)"); break;
3754 case 5: strcat (buffer
, " (DIALOG)"); break;
3755 case 6: strcat (buffer
, " (STRING)"); is_string
= true; break;
3756 case 7: strcat (buffer
, " (FONTDIR)"); break;
3757 case 8: strcat (buffer
, " (FONT)"); break;
3758 case 9: strcat (buffer
, " (ACCELERATOR)"); break;
3759 case 10: strcat (buffer
, " (RCDATA)"); break;
3760 case 11: strcat (buffer
, " (MESSAGETABLE)"); break;
3761 case 12: strcat (buffer
, " (GROUP_CURSOR)"); break;
3762 case 14: strcat (buffer
, " (GROUP_ICON)"); break;
3763 case 16: strcat (buffer
, " (VERSION)"); break;
3764 case 17: strcat (buffer
, " (DLGINCLUDE)"); break;
3765 case 19: strcat (buffer
, " (PLUGPLAY)"); break;
3766 case 20: strcat (buffer
, " (VXD)"); break;
3767 case 21: strcat (buffer
, " (ANICURSOR)"); break;
3768 case 22: strcat (buffer
, " (ANIICON)"); break;
3769 case 23: strcat (buffer
, " (HTML)"); break;
3770 case 24: strcat (buffer
, " (MANIFEST)"); break;
3771 case 240: strcat (buffer
, " (DLGINIT)"); break;
3772 case 241: strcat (buffer
, " (TOOLBAR)"); break;
3777 if (dir
!= NULL
&& dir
->entry
!= NULL
)
3779 strcat (buffer
, " name: ");
3780 if (dir
->entry
->is_name
)
3781 rsrc_print_name (buffer
+ strlen (buffer
), dir
->entry
->name_id
.name
);
3784 unsigned int id
= dir
->entry
->name_id
.id
;
3786 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3789 sprintf (buffer
+ strlen (buffer
), " (resource id range: %d - %d)",
3790 (id
- 1) << 4, (id
<< 4) - 1);
3796 strcat (buffer
, " lang: ");
3799 rsrc_print_name (buffer
+ strlen (buffer
), entry
->name_id
.name
);
3801 sprintf (buffer
+ strlen (buffer
), "%x", entry
->name_id
.id
);
3807 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3808 their ID is stored in the NAME entry. The bottom four bits are used as
3809 an index into unicode string table that makes up the data of the leaf.
3810 So identical type-name-lang string resources may not actually be
3813 This function is called when we have detected two string resources with
3814 match top-28-bit IDs. We have to scan the string tables inside the leaves
3815 and discover if there are any real collisions. If there are then we report
3816 them and return FALSE. Otherwise we copy any strings from B into A and
3817 then return TRUE. */
3820 rsrc_merge_string_entries (rsrc_entry
* a ATTRIBUTE_UNUSED
,
3821 rsrc_entry
* b ATTRIBUTE_UNUSED
)
3823 unsigned int copy_needed
= 0;
3827 bfd_byte
* new_data
;
3830 /* Step one: Find out what we have to do. */
3831 BFD_ASSERT (! a
->is_dir
);
3832 astring
= a
->value
.leaf
->data
;
3834 BFD_ASSERT (! b
->is_dir
);
3835 bstring
= b
->value
.leaf
->data
;
3837 for (i
= 0; i
< 16; i
++)
3839 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3840 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3844 copy_needed
+= blen
* 2;
3848 else if (alen
!= blen
)
3849 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3851 /* alen == blen != 0. We might have two identical strings. If so we
3852 can ignore the second one. There is no need for wchar_t vs UTF-16
3853 theatrics here - we are only interested in (case sensitive) equality. */
3854 else if (memcmp (astring
+ 2, bstring
+ 2, alen
* 2) != 0)
3857 astring
+= (alen
+ 1) * 2;
3858 bstring
+= (blen
+ 1) * 2;
3863 if (a
->parent
!= NULL
3864 && a
->parent
->entry
!= NULL
3865 && !a
->parent
->entry
->is_name
)
3866 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3867 ((a
->parent
->entry
->name_id
.id
- 1) << 4) + i
);
3871 if (copy_needed
== 0)
3874 /* If we reach here then A and B must both have non-colliding strings.
3875 (We never get string resources with fully empty string tables).
3876 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3878 new_data
= bfd_malloc (a
->value
.leaf
->size
+ copy_needed
);
3879 if (new_data
== NULL
)
3883 astring
= a
->value
.leaf
->data
;
3884 bstring
= b
->value
.leaf
->data
;
3886 for (i
= 0; i
< 16; i
++)
3888 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3889 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3893 memcpy (nstring
, astring
, (alen
+ 1) * 2);
3894 nstring
+= (alen
+ 1) * 2;
3898 memcpy (nstring
, bstring
, (blen
+ 1) * 2);
3899 nstring
+= (blen
+ 1) * 2;
3907 astring
+= (alen
+ 1) * 2;
3908 bstring
+= (blen
+ 1) * 2;
3911 BFD_ASSERT (nstring
- new_data
== (signed) (a
->value
.leaf
->size
+ copy_needed
));
3913 free (a
->value
.leaf
->data
);
3914 a
->value
.leaf
->data
= new_data
;
3915 a
->value
.leaf
->size
+= copy_needed
;
3920 static void rsrc_merge (rsrc_entry
*, rsrc_entry
*);
3922 /* Sort the entries in given part of the directory.
3923 We use an old fashioned bubble sort because we are dealing
3924 with lists and we want to handle matches specially. */
3927 rsrc_sort_entries (rsrc_dir_chain
*chain
,
3929 rsrc_directory
*dir
)
3933 rsrc_entry
** points_to_entry
;
3936 if (chain
->num_entries
< 2)
3942 points_to_entry
= & chain
->first_entry
;
3943 entry
= * points_to_entry
;
3944 next
= entry
->next_entry
;
3948 signed int cmp
= rsrc_cmp (is_name
, entry
, next
);
3952 entry
->next_entry
= next
->next_entry
;
3953 next
->next_entry
= entry
;
3954 * points_to_entry
= next
;
3955 points_to_entry
= & next
->next_entry
;
3956 next
= entry
->next_entry
;
3961 if (entry
->is_dir
&& next
->is_dir
)
3963 /* When we encounter identical directory entries we have to
3964 merge them together. The exception to this rule is for
3965 resource manifests - there can only be one of these,
3966 even if they differ in language. Zero-language manifests
3967 are assumed to be default manifests (provided by the
3968 Cygwin/MinGW build system) and these can be silently dropped,
3969 unless that would reduce the number of manifests to zero.
3970 There should only ever be one non-zero lang manifest -
3971 if there are more it is an error. A non-zero lang
3972 manifest takes precedence over a default manifest. */
3974 && entry
->name_id
.id
== 1
3976 && dir
->entry
!= NULL
3977 && !dir
->entry
->is_name
3978 && dir
->entry
->name_id
.id
== 0x18)
3980 if (next
->value
.directory
->names
.num_entries
== 0
3981 && next
->value
.directory
->ids
.num_entries
== 1
3982 && !next
->value
.directory
->ids
.first_entry
->is_name
3983 && next
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3984 /* Fall through so that NEXT is dropped. */
3986 else if (entry
->value
.directory
->names
.num_entries
== 0
3987 && entry
->value
.directory
->ids
.num_entries
== 1
3988 && !entry
->value
.directory
->ids
.first_entry
->is_name
3989 && entry
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3991 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
3992 entry
->next_entry
= next
->next_entry
;
3993 next
->next_entry
= entry
;
3994 * points_to_entry
= next
;
3995 points_to_entry
= & next
->next_entry
;
3996 next
= entry
->next_entry
;
4001 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
4002 bfd_set_error (bfd_error_file_truncated
);
4006 /* Unhook NEXT from the chain. */
4007 /* FIXME: memory loss here. */
4008 entry
->next_entry
= next
->next_entry
;
4009 chain
->num_entries
--;
4010 if (chain
->num_entries
< 2)
4012 next
= next
->next_entry
;
4015 rsrc_merge (entry
, next
);
4017 else if (entry
->is_dir
!= next
->is_dir
)
4019 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
4020 bfd_set_error (bfd_error_file_truncated
);
4025 /* Otherwise with identical leaves we issue an error
4026 message - because there should never be duplicates.
4027 The exception is Type 18/Name 1/Lang 0 which is the
4028 defaul manifest - this can just be dropped. */
4030 && entry
->name_id
.id
== 0
4032 && dir
->entry
!= NULL
4033 && !dir
->entry
->is_name
4034 && dir
->entry
->name_id
.id
== 1
4035 && dir
->entry
->parent
!= NULL
4036 && dir
->entry
->parent
->entry
!= NULL
4037 && !dir
->entry
->parent
->entry
->is_name
4038 && dir
->entry
->parent
->entry
->name_id
.id
== 0x18 /* RT_MANIFEST */)
4040 else if (dir
!= NULL
4041 && dir
->entry
!= NULL
4042 && dir
->entry
->parent
!= NULL
4043 && dir
->entry
->parent
->entry
!= NULL
4044 && !dir
->entry
->parent
->entry
->is_name
4045 && dir
->entry
->parent
->entry
->name_id
.id
== 0x6 /* RT_STRING */)
4047 /* Strings need special handling. */
4048 if (! rsrc_merge_string_entries (entry
, next
))
4050 /* _bfd_error_handler should have been called inside merge_strings. */
4051 bfd_set_error (bfd_error_file_truncated
);
4058 || dir
->entry
== NULL
4059 || dir
->entry
->parent
== NULL
4060 || dir
->entry
->parent
->entry
== NULL
)
4061 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
4066 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
4067 rsrc_resource_name (entry
, dir
, buff
));
4069 bfd_set_error (bfd_error_file_truncated
);
4074 /* Unhook NEXT from the chain. */
4075 entry
->next_entry
= next
->next_entry
;
4076 chain
->num_entries
--;
4077 if (chain
->num_entries
< 2)
4079 next
= next
->next_entry
;
4083 points_to_entry
= & entry
->next_entry
;
4085 next
= next
->next_entry
;
4090 chain
->last_entry
= entry
;
4095 /* Attach B's chain onto A. */
4097 rsrc_attach_chain (rsrc_dir_chain
* achain
, rsrc_dir_chain
* bchain
)
4099 if (bchain
->num_entries
== 0)
4102 achain
->num_entries
+= bchain
->num_entries
;
4104 if (achain
->first_entry
== NULL
)
4106 achain
->first_entry
= bchain
->first_entry
;
4107 achain
->last_entry
= bchain
->last_entry
;
4111 achain
->last_entry
->next_entry
= bchain
->first_entry
;
4112 achain
->last_entry
= bchain
->last_entry
;
4115 bchain
->num_entries
= 0;
4116 bchain
->first_entry
= bchain
->last_entry
= NULL
;
4120 rsrc_merge (struct rsrc_entry
* a
, struct rsrc_entry
* b
)
4122 rsrc_directory
* adir
;
4123 rsrc_directory
* bdir
;
4125 BFD_ASSERT (a
->is_dir
);
4126 BFD_ASSERT (b
->is_dir
);
4128 adir
= a
->value
.directory
;
4129 bdir
= b
->value
.directory
;
4131 if (adir
->characteristics
!= bdir
->characteristics
)
4133 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics"));
4134 bfd_set_error (bfd_error_file_truncated
);
4138 if (adir
->major
!= bdir
->major
|| adir
->minor
!= bdir
->minor
)
4140 _bfd_error_handler (_(".rsrc merge failure: differing directory versions"));
4141 bfd_set_error (bfd_error_file_truncated
);
4145 /* Attach B's name chain to A. */
4146 rsrc_attach_chain (& adir
->names
, & bdir
->names
);
4148 /* Attach B's ID chain to A. */
4149 rsrc_attach_chain (& adir
->ids
, & bdir
->ids
);
4151 /* Now sort A's entries. */
4152 rsrc_sort_entries (& adir
->names
, true, adir
);
4153 rsrc_sort_entries (& adir
->ids
, false, adir
);
4156 /* Check the .rsrc section. If it contains multiple concatenated
4157 resources then we must merge them properly. Otherwise Windows
4158 will ignore all but the first set. */
4161 rsrc_process_section (bfd
* abfd
,
4162 struct coff_final_link_info
* pfinfo
)
4164 rsrc_directory new_table
;
4170 bfd_byte
* datastart
;
4172 bfd_byte
* new_data
;
4173 unsigned int num_resource_sets
;
4174 rsrc_directory
* type_tables
;
4175 rsrc_write_data write_data
;
4178 unsigned int num_input_rsrc
= 0;
4179 unsigned int max_num_input_rsrc
= 4;
4180 ptrdiff_t * rsrc_sizes
= NULL
;
4182 new_table
.names
.num_entries
= 0;
4183 new_table
.ids
.num_entries
= 0;
4185 sec
= bfd_get_section_by_name (abfd
, ".rsrc");
4186 if (sec
== NULL
|| (size
= sec
->rawsize
) == 0)
4189 pe
= pe_data (abfd
);
4193 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4195 data
= bfd_malloc (size
);
4201 if (! bfd_get_section_contents (abfd
, sec
, data
, 0, size
))
4204 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4205 their lengths. Note - we rely upon the fact that the linker script
4206 does *not* sort the input .rsrc sections, so that the order in the
4207 linkinfo list matches the order in the output .rsrc section.
4209 We need to know the lengths because each input .rsrc section has padding
4210 at the end of a variable amount. (It does not appear to be based upon
4211 the section alignment or the file alignment). We need to skip any
4212 padding bytes when parsing the input .rsrc sections. */
4213 rsrc_sizes
= bfd_malloc (max_num_input_rsrc
* sizeof * rsrc_sizes
);
4214 if (rsrc_sizes
== NULL
)
4217 for (input
= pfinfo
->info
->input_bfds
;
4219 input
= input
->link
.next
)
4221 asection
* rsrc_sec
= bfd_get_section_by_name (input
, ".rsrc");
4223 /* PR 18372 - skip discarded .rsrc sections. */
4224 if (rsrc_sec
!= NULL
&& !discarded_section (rsrc_sec
))
4226 if (num_input_rsrc
== max_num_input_rsrc
)
4228 max_num_input_rsrc
+= 10;
4229 rsrc_sizes
= bfd_realloc (rsrc_sizes
, max_num_input_rsrc
4230 * sizeof * rsrc_sizes
);
4231 if (rsrc_sizes
== NULL
)
4235 BFD_ASSERT (rsrc_sec
->size
> 0);
4236 rsrc_sizes
[num_input_rsrc
++] = rsrc_sec
->size
;
4240 if (num_input_rsrc
< 2)
4243 /* Step one: Walk the section, computing the size of the tables,
4244 leaves and data and decide if we need to do anything. */
4245 dataend
= data
+ size
;
4246 num_resource_sets
= 0;
4248 while (data
< dataend
)
4250 bfd_byte
* p
= data
;
4252 data
= rsrc_count_directory (abfd
, data
, data
, dataend
, rva_bias
);
4256 /* Corrupted .rsrc section - cannot merge. */
4257 _bfd_error_handler (_("%pB: .rsrc merge failure: corrupt .rsrc section"),
4259 bfd_set_error (bfd_error_file_truncated
);
4263 if ((data
- p
) > rsrc_sizes
[num_resource_sets
])
4265 _bfd_error_handler (_("%pB: .rsrc merge failure: unexpected .rsrc size"),
4267 bfd_set_error (bfd_error_file_truncated
);
4270 /* FIXME: Should we add a check for "data - p" being much smaller
4271 than rsrc_sizes[num_resource_sets] ? */
4273 data
= p
+ rsrc_sizes
[num_resource_sets
];
4274 rva_bias
+= data
- p
;
4275 ++ num_resource_sets
;
4277 BFD_ASSERT (num_resource_sets
== num_input_rsrc
);
4279 /* Step two: Walk the data again, building trees of the resources. */
4281 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4283 type_tables
= bfd_malloc (num_resource_sets
* sizeof * type_tables
);
4284 if (type_tables
== NULL
)
4288 while (data
< dataend
)
4290 bfd_byte
* p
= data
;
4292 (void) rsrc_parse_directory (abfd
, type_tables
+ indx
, data
, data
,
4293 dataend
, rva_bias
, NULL
);
4294 data
= p
+ rsrc_sizes
[indx
];
4295 rva_bias
+= data
- p
;
4298 BFD_ASSERT (indx
== num_resource_sets
);
4300 /* Step three: Merge the top level tables (there can be only one).
4302 We must ensure that the merged entries are in ascending order.
4304 We also thread the top level table entries from the old tree onto
4305 the new table, so that they can be pulled off later. */
4307 /* FIXME: Should we verify that all type tables are the same ? */
4308 new_table
.characteristics
= type_tables
[0].characteristics
;
4309 new_table
.time
= type_tables
[0].time
;
4310 new_table
.major
= type_tables
[0].major
;
4311 new_table
.minor
= type_tables
[0].minor
;
4313 /* Chain the NAME entries onto the table. */
4314 new_table
.names
.first_entry
= NULL
;
4315 new_table
.names
.last_entry
= NULL
;
4317 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4318 rsrc_attach_chain (& new_table
.names
, & type_tables
[indx
].names
);
4320 rsrc_sort_entries (& new_table
.names
, true, & new_table
);
4322 /* Chain the ID entries onto the table. */
4323 new_table
.ids
.first_entry
= NULL
;
4324 new_table
.ids
.last_entry
= NULL
;
4326 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4327 rsrc_attach_chain (& new_table
.ids
, & type_tables
[indx
].ids
);
4329 rsrc_sort_entries (& new_table
.ids
, false, & new_table
);
4331 /* Step four: Create new contents for the .rsrc section. */
4332 /* Step four point one: Compute the size of each region of the .rsrc section.
4333 We do this now, rather than earlier, as the merging above may have dropped
4335 sizeof_leaves
= sizeof_strings
= sizeof_tables_and_entries
= 0;
4336 rsrc_compute_region_sizes (& new_table
);
4337 /* We increment sizeof_strings to make sure that resource data
4338 starts on an 8-byte boundary. FIXME: Is this correct ? */
4339 sizeof_strings
= (sizeof_strings
+ 7) & ~ 7;
4341 new_data
= bfd_zalloc (abfd
, size
);
4342 if (new_data
== NULL
)
4345 write_data
.abfd
= abfd
;
4346 write_data
.datastart
= new_data
;
4347 write_data
.next_table
= new_data
;
4348 write_data
.next_leaf
= new_data
+ sizeof_tables_and_entries
;
4349 write_data
.next_string
= write_data
.next_leaf
+ sizeof_leaves
;
4350 write_data
.next_data
= write_data
.next_string
+ sizeof_strings
;
4351 write_data
.rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4353 rsrc_write_directory (& write_data
, & new_table
);
4355 /* Step five: Replace the old contents with the new.
4356 We don't recompute the size as it's too late here to shrink section.
4357 See PR ld/20193 for more details. */
4358 bfd_set_section_contents (pfinfo
->output_bfd
, sec
, new_data
, 0, size
);
4359 sec
->size
= sec
->rawsize
= size
;
4362 /* Step six: Free all the memory that we have used. */
4363 /* FIXME: Free the resource tree, if we have one. */
4368 /* Handle the .idata section and other things that need symbol table
4372 _bfd_XXi_final_link_postscript (bfd
* abfd
, struct coff_final_link_info
*pfinfo
)
4374 struct coff_link_hash_entry
*h1
;
4375 struct bfd_link_info
*info
= pfinfo
->info
;
4378 /* There are a few fields that need to be filled in now while we
4379 have symbol table access.
4381 The .idata subsections aren't directly available as sections, but
4382 they are in the symbol table, so get them from there. */
4384 /* The import directory. This is the address of .idata$2, with size
4385 of .idata$2 + .idata$3. */
4386 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4387 ".idata$2", false, false, true);
4390 /* PR ld/2729: We cannot rely upon all the output sections having been
4391 created properly, so check before referencing them. Issue a warning
4392 message for any sections tht could not be found. */
4393 if ((h1
->root
.type
== bfd_link_hash_defined
4394 || h1
->root
.type
== bfd_link_hash_defweak
)
4395 && h1
->root
.u
.def
.section
!= NULL
4396 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4397 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
=
4398 (h1
->root
.u
.def
.value
4399 + h1
->root
.u
.def
.section
->output_section
->vma
4400 + h1
->root
.u
.def
.section
->output_offset
);
4404 (_("%pB: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4409 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4410 ".idata$4", false, false, true);
4412 && (h1
->root
.type
== bfd_link_hash_defined
4413 || h1
->root
.type
== bfd_link_hash_defweak
)
4414 && h1
->root
.u
.def
.section
!= NULL
4415 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4416 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].Size
=
4417 ((h1
->root
.u
.def
.value
4418 + h1
->root
.u
.def
.section
->output_section
->vma
4419 + h1
->root
.u
.def
.section
->output_offset
)
4420 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
);
4424 (_("%pB: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4429 /* The import address table. This is the size/address of
4431 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4432 ".idata$5", false, false, true);
4434 && (h1
->root
.type
== bfd_link_hash_defined
4435 || h1
->root
.type
== bfd_link_hash_defweak
)
4436 && h1
->root
.u
.def
.section
!= NULL
4437 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4438 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4439 (h1
->root
.u
.def
.value
4440 + h1
->root
.u
.def
.section
->output_section
->vma
4441 + h1
->root
.u
.def
.section
->output_offset
);
4445 (_("%pB: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4450 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4451 ".idata$6", false, false, true);
4453 && (h1
->root
.type
== bfd_link_hash_defined
4454 || h1
->root
.type
== bfd_link_hash_defweak
)
4455 && h1
->root
.u
.def
.section
!= NULL
4456 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4457 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4458 ((h1
->root
.u
.def
.value
4459 + h1
->root
.u
.def
.section
->output_section
->vma
4460 + h1
->root
.u
.def
.section
->output_offset
)
4461 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
);
4465 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4472 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4473 "__IAT_start__", false, false, true);
4475 && (h1
->root
.type
== bfd_link_hash_defined
4476 || h1
->root
.type
== bfd_link_hash_defweak
)
4477 && h1
->root
.u
.def
.section
!= NULL
4478 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4483 (h1
->root
.u
.def
.value
4484 + h1
->root
.u
.def
.section
->output_section
->vma
4485 + h1
->root
.u
.def
.section
->output_offset
);
4487 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4488 "__IAT_end__", false, false, true);
4490 && (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
)
4495 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4496 ((h1
->root
.u
.def
.value
4497 + h1
->root
.u
.def
.section
->output_section
->vma
4498 + h1
->root
.u
.def
.section
->output_offset
)
4500 if (pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
!= 0)
4501 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4502 iat_va
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
4507 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4508 " because .idata$6 is missing"), abfd
);
4514 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4515 (bfd_get_symbol_leading_char (abfd
) != 0
4516 ? "__tls_used" : "_tls_used"),
4517 false, false, true);
4520 if ((h1
->root
.type
== bfd_link_hash_defined
4521 || h1
->root
.type
== bfd_link_hash_defweak
)
4522 && h1
->root
.u
.def
.section
!= NULL
4523 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4524 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].VirtualAddress
=
4525 (h1
->root
.u
.def
.value
4526 + h1
->root
.u
.def
.section
->output_section
->vma
4527 + h1
->root
.u
.def
.section
->output_offset
4528 - pe_data (abfd
)->pe_opthdr
.ImageBase
);
4532 (_("%pB: unable to fill in DataDictionary[9] because __tls_used is missing"),
4536 /* According to PECOFF sepcifications by Microsoft version 8.2
4537 the TLS data directory consists of 4 pointers, followed
4538 by two 4-byte integer. This implies that the total size
4539 is different for 32-bit and 64-bit executables. */
4540 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
4541 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x18;
4543 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x28;
4547 /* If there is a .pdata section and we have linked pdata finally, we
4548 need to sort the entries ascending. */
4549 #if !defined(COFF_WITH_pep) && (defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64))
4551 asection
*sec
= bfd_get_section_by_name (abfd
, ".pdata");
4555 bfd_size_type x
= sec
->rawsize
;
4556 bfd_byte
*tmp_data
= NULL
;
4559 tmp_data
= bfd_malloc (x
);
4561 if (tmp_data
!= NULL
)
4563 if (bfd_get_section_contents (abfd
, sec
, tmp_data
, 0, x
))
4567 12, sort_x64_pdata
);
4568 bfd_set_section_contents (pfinfo
->output_bfd
, sec
,
4579 rsrc_process_section (abfd
, pfinfo
);
4581 /* If we couldn't find idata$2, we either have an excessively
4582 trivial program or are in DEEP trouble; we have to assume trivial