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_LINKER_CREATED
);
194 sec
= bfd_make_section_anyway_with_flags (abfd
, sec_name
, flags
);
197 _bfd_error_handler (_("%pB: unable to create fake empty section"),
202 sec
->alignment_power
= 2;
203 sec
->target_index
= unused_section_number
;
205 in
->n_scnum
= unused_section_number
;
207 in
->n_sclass
= C_STAT
;
213 abs_finder (bfd
* abfd ATTRIBUTE_UNUSED
, asection
* sec
, void * data
)
215 bfd_vma abs_val
= * (bfd_vma
*) data
;
217 return (sec
->vma
<= abs_val
) && ((sec
->vma
+ (1ULL << 32)) > abs_val
);
221 _bfd_XXi_swap_sym_out (bfd
* abfd
, void * inp
, void * extp
)
223 struct internal_syment
*in
= (struct internal_syment
*) inp
;
224 SYMENT
*ext
= (SYMENT
*) extp
;
226 if (in
->_n
._n_name
[0] == 0)
228 H_PUT_32 (abfd
, 0, ext
->e
.e
.e_zeroes
);
229 H_PUT_32 (abfd
, in
->_n
._n_n
._n_offset
, ext
->e
.e
.e_offset
);
232 memcpy (ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
234 /* The PE32 and PE32+ formats only use 4 bytes to hold the value of a
235 symbol. This is a problem on 64-bit targets where we can generate
236 absolute symbols with values >= 1^32. We try to work around this
237 problem by finding a section whose base address is sufficient to
238 reduce the absolute value to < 1^32, and then transforming the
239 symbol into a section relative symbol. This of course is a hack. */
240 if (sizeof (in
->n_value
) > 4
241 /* The strange computation of the shift amount is here in order to
242 avoid a compile time warning about the comparison always being
243 false. It does not matter if this test fails to work as expected
244 as the worst that can happen is that some absolute symbols are
245 needlessly converted into section relative symbols. */
246 && in
->n_value
> ((1ULL << (sizeof (in
->n_value
) > 4 ? 32 : 31)) - 1)
247 && in
->n_scnum
== N_ABS
)
251 sec
= bfd_sections_find_if (abfd
, abs_finder
, & in
->n_value
);
254 in
->n_value
-= sec
->vma
;
255 in
->n_scnum
= sec
->target_index
;
257 /* else: FIXME: The value is outside the range of any section. This
258 happens for __image_base__ and __ImageBase and maybe some other
259 symbols as well. We should find a way to handle these values. */
262 H_PUT_32 (abfd
, in
->n_value
, ext
->e_value
);
263 H_PUT_16 (abfd
, in
->n_scnum
, ext
->e_scnum
);
265 if (sizeof (ext
->e_type
) == 2)
266 H_PUT_16 (abfd
, in
->n_type
, ext
->e_type
);
268 H_PUT_32 (abfd
, in
->n_type
, ext
->e_type
);
270 H_PUT_8 (abfd
, in
->n_sclass
, ext
->e_sclass
);
271 H_PUT_8 (abfd
, in
->n_numaux
, ext
->e_numaux
);
277 _bfd_XXi_swap_aux_in (bfd
* abfd
,
281 int indx ATTRIBUTE_UNUSED
,
282 int numaux ATTRIBUTE_UNUSED
,
285 AUXENT
*ext
= (AUXENT
*) ext1
;
286 union internal_auxent
*in
= (union internal_auxent
*) in1
;
288 /* PR 17521: Make sure that all fields in the aux structure
290 memset (in
, 0, sizeof * in
);
294 if (ext
->x_file
.x_fname
[0] == 0)
296 in
->x_file
.x_n
.x_n
.x_zeroes
= 0;
297 in
->x_file
.x_n
.x_n
.x_offset
= H_GET_32 (abfd
, ext
->x_file
.x_n
.x_offset
);
300 memcpy (in
->x_file
.x_n
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
308 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN (abfd
, ext
);
309 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC (abfd
, ext
);
310 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO (abfd
, ext
);
311 in
->x_scn
.x_checksum
= H_GET_32 (abfd
, ext
->x_scn
.x_checksum
);
312 in
->x_scn
.x_associated
= H_GET_16 (abfd
, ext
->x_scn
.x_associated
);
313 in
->x_scn
.x_comdat
= H_GET_8 (abfd
, ext
->x_scn
.x_comdat
);
319 in
->x_sym
.x_tagndx
.u32
= H_GET_32 (abfd
, ext
->x_sym
.x_tagndx
);
320 in
->x_sym
.x_tvndx
= H_GET_16 (abfd
, ext
->x_sym
.x_tvndx
);
322 if (in_class
== C_BLOCK
|| in_class
== C_FCN
|| ISFCN (type
)
325 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR (abfd
, ext
);
326 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.u32
= GET_FCN_ENDNDX (abfd
, ext
);
330 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0] =
331 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
332 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1] =
333 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
334 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2] =
335 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
336 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3] =
337 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
342 in
->x_sym
.x_misc
.x_fsize
= H_GET_32 (abfd
, ext
->x_sym
.x_misc
.x_fsize
);
346 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO (abfd
, ext
);
347 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE (abfd
, ext
);
352 _bfd_XXi_swap_aux_out (bfd
* abfd
,
356 int indx ATTRIBUTE_UNUSED
,
357 int numaux ATTRIBUTE_UNUSED
,
360 union internal_auxent
*in
= (union internal_auxent
*) inp
;
361 AUXENT
*ext
= (AUXENT
*) extp
;
363 memset (ext
, 0, AUXESZ
);
368 if (in
->x_file
.x_n
.x_fname
[0] == 0)
370 H_PUT_32 (abfd
, 0, ext
->x_file
.x_n
.x_zeroes
);
371 H_PUT_32 (abfd
, in
->x_file
.x_n
.x_n
.x_offset
, ext
->x_file
.x_n
.x_offset
);
374 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_n
.x_fname
, sizeof (ext
->x_file
.x_fname
));
383 PUT_SCN_SCNLEN (abfd
, in
->x_scn
.x_scnlen
, ext
);
384 PUT_SCN_NRELOC (abfd
, in
->x_scn
.x_nreloc
, ext
);
385 PUT_SCN_NLINNO (abfd
, in
->x_scn
.x_nlinno
, ext
);
386 H_PUT_32 (abfd
, in
->x_scn
.x_checksum
, ext
->x_scn
.x_checksum
);
387 H_PUT_16 (abfd
, in
->x_scn
.x_associated
, ext
->x_scn
.x_associated
);
388 H_PUT_8 (abfd
, in
->x_scn
.x_comdat
, ext
->x_scn
.x_comdat
);
394 H_PUT_32 (abfd
, in
->x_sym
.x_tagndx
.u32
, ext
->x_sym
.x_tagndx
);
395 H_PUT_16 (abfd
, in
->x_sym
.x_tvndx
, ext
->x_sym
.x_tvndx
);
397 if (in_class
== C_BLOCK
|| in_class
== C_FCN
|| ISFCN (type
)
400 PUT_FCN_LNNOPTR (abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
401 PUT_FCN_ENDNDX (abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.u32
, ext
);
405 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0],
406 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
407 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1],
408 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
409 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2],
410 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
411 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3],
412 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
416 H_PUT_32 (abfd
, in
->x_sym
.x_misc
.x_fsize
, ext
->x_sym
.x_misc
.x_fsize
);
419 PUT_LNSZ_LNNO (abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
420 PUT_LNSZ_SIZE (abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
427 _bfd_XXi_swap_lineno_in (bfd
* abfd
, void * ext1
, void * in1
)
429 LINENO
*ext
= (LINENO
*) ext1
;
430 struct internal_lineno
*in
= (struct internal_lineno
*) in1
;
432 in
->l_addr
.l_symndx
= H_GET_32 (abfd
, ext
->l_addr
.l_symndx
);
433 in
->l_lnno
= GET_LINENO_LNNO (abfd
, ext
);
437 _bfd_XXi_swap_lineno_out (bfd
* abfd
, void * inp
, void * outp
)
439 struct internal_lineno
*in
= (struct internal_lineno
*) inp
;
440 struct external_lineno
*ext
= (struct external_lineno
*) outp
;
441 H_PUT_32 (abfd
, in
->l_addr
.l_symndx
, ext
->l_addr
.l_symndx
);
443 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
448 _bfd_XXi_swap_aouthdr_in (bfd
* abfd
,
452 PEAOUTHDR
* src
= (PEAOUTHDR
*) aouthdr_ext1
;
453 AOUTHDR
* aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
454 struct internal_aouthdr
*aouthdr_int
455 = (struct internal_aouthdr
*) aouthdr_int1
;
456 struct internal_extra_pe_aouthdr
*a
= &aouthdr_int
->pe
;
458 aouthdr_int
->magic
= H_GET_16 (abfd
, aouthdr_ext
->magic
);
459 aouthdr_int
->vstamp
= H_GET_16 (abfd
, aouthdr_ext
->vstamp
);
460 aouthdr_int
->tsize
= GET_AOUTHDR_TSIZE (abfd
, aouthdr_ext
->tsize
);
461 aouthdr_int
->dsize
= GET_AOUTHDR_DSIZE (abfd
, aouthdr_ext
->dsize
);
462 aouthdr_int
->bsize
= GET_AOUTHDR_BSIZE (abfd
, aouthdr_ext
->bsize
);
463 aouthdr_int
->entry
= GET_AOUTHDR_ENTRY (abfd
, aouthdr_ext
->entry
);
464 aouthdr_int
->text_start
=
465 GET_AOUTHDR_TEXT_START (abfd
, aouthdr_ext
->text_start
);
467 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
468 /* PE32+ does not have data_start member! */
469 aouthdr_int
->data_start
=
470 GET_AOUTHDR_DATA_START (abfd
, aouthdr_ext
->data_start
);
471 a
->BaseOfData
= aouthdr_int
->data_start
;
474 a
->Magic
= aouthdr_int
->magic
;
475 a
->MajorLinkerVersion
= H_GET_8 (abfd
, aouthdr_ext
->vstamp
);
476 a
->MinorLinkerVersion
= H_GET_8 (abfd
, aouthdr_ext
->vstamp
+ 1);
477 a
->SizeOfCode
= aouthdr_int
->tsize
;
478 a
->SizeOfInitializedData
= aouthdr_int
->dsize
;
479 a
->SizeOfUninitializedData
= aouthdr_int
->bsize
;
480 a
->AddressOfEntryPoint
= aouthdr_int
->entry
;
481 a
->BaseOfCode
= aouthdr_int
->text_start
;
482 a
->ImageBase
= GET_OPTHDR_IMAGE_BASE (abfd
, src
->ImageBase
);
483 a
->SectionAlignment
= H_GET_32 (abfd
, src
->SectionAlignment
);
484 a
->FileAlignment
= H_GET_32 (abfd
, src
->FileAlignment
);
485 a
->MajorOperatingSystemVersion
=
486 H_GET_16 (abfd
, src
->MajorOperatingSystemVersion
);
487 a
->MinorOperatingSystemVersion
=
488 H_GET_16 (abfd
, src
->MinorOperatingSystemVersion
);
489 a
->MajorImageVersion
= H_GET_16 (abfd
, src
->MajorImageVersion
);
490 a
->MinorImageVersion
= H_GET_16 (abfd
, src
->MinorImageVersion
);
491 a
->MajorSubsystemVersion
= H_GET_16 (abfd
, src
->MajorSubsystemVersion
);
492 a
->MinorSubsystemVersion
= H_GET_16 (abfd
, src
->MinorSubsystemVersion
);
493 a
->Reserved1
= H_GET_32 (abfd
, src
->Reserved1
);
494 a
->SizeOfImage
= H_GET_32 (abfd
, src
->SizeOfImage
);
495 a
->SizeOfHeaders
= H_GET_32 (abfd
, src
->SizeOfHeaders
);
496 a
->CheckSum
= H_GET_32 (abfd
, src
->CheckSum
);
497 a
->Subsystem
= H_GET_16 (abfd
, src
->Subsystem
);
498 a
->DllCharacteristics
= H_GET_16 (abfd
, src
->DllCharacteristics
);
499 a
->SizeOfStackReserve
=
500 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd
, src
->SizeOfStackReserve
);
501 a
->SizeOfStackCommit
=
502 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd
, src
->SizeOfStackCommit
);
503 a
->SizeOfHeapReserve
=
504 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd
, src
->SizeOfHeapReserve
);
505 a
->SizeOfHeapCommit
=
506 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd
, src
->SizeOfHeapCommit
);
507 a
->LoaderFlags
= H_GET_32 (abfd
, src
->LoaderFlags
);
508 a
->NumberOfRvaAndSizes
= H_GET_32 (abfd
, src
->NumberOfRvaAndSizes
);
510 /* PR 17512: Don't blindly trust NumberOfRvaAndSizes. */
513 idx
< a
->NumberOfRvaAndSizes
&& idx
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
;
516 /* If data directory is empty, rva also should be 0. */
517 int size
= H_GET_32 (abfd
, src
->DataDirectory
[idx
][1]);
518 int vma
= size
? H_GET_32 (abfd
, src
->DataDirectory
[idx
][0]) : 0;
520 a
->DataDirectory
[idx
].Size
= size
;
521 a
->DataDirectory
[idx
].VirtualAddress
= vma
;
524 while (idx
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
)
526 a
->DataDirectory
[idx
].Size
= 0;
527 a
->DataDirectory
[idx
].VirtualAddress
= 0;
531 if (aouthdr_int
->entry
)
533 aouthdr_int
->entry
+= a
->ImageBase
;
534 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
535 aouthdr_int
->entry
&= 0xffffffff;
539 if (aouthdr_int
->tsize
)
541 aouthdr_int
->text_start
+= a
->ImageBase
;
542 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
543 aouthdr_int
->text_start
&= 0xffffffff;
547 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
548 /* PE32+ does not have data_start member! */
549 if (aouthdr_int
->dsize
)
551 aouthdr_int
->data_start
+= a
->ImageBase
;
552 aouthdr_int
->data_start
&= 0xffffffff;
557 /* A support function for below. */
560 add_data_entry (bfd
* abfd
,
561 struct internal_extra_pe_aouthdr
*aout
,
566 asection
*sec
= bfd_get_section_by_name (abfd
, name
);
568 /* Add import directory information if it exists. */
570 && (coff_section_data (abfd
, sec
) != NULL
)
571 && (pei_section_data (abfd
, sec
) != NULL
))
573 /* If data directory is empty, rva also should be 0. */
574 int size
= pei_section_data (abfd
, sec
)->virt_size
;
575 aout
->DataDirectory
[idx
].Size
= size
;
579 aout
->DataDirectory
[idx
].VirtualAddress
=
580 (sec
->vma
- base
) & 0xffffffff;
581 sec
->flags
|= SEC_DATA
;
587 _bfd_XXi_swap_aouthdr_out (bfd
* abfd
, void * in
, void * out
)
589 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*) in
;
590 pe_data_type
*pe
= pe_data (abfd
);
591 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
592 PEAOUTHDR
*aouthdr_out
= (PEAOUTHDR
*) out
;
594 IMAGE_DATA_DIRECTORY idata2
, idata5
, tls
;
596 sa
= extra
->SectionAlignment
;
597 fa
= extra
->FileAlignment
;
598 ib
= extra
->ImageBase
;
600 idata2
= pe
->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
];
601 idata5
= pe
->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
];
602 tls
= pe
->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
];
604 if (aouthdr_in
->tsize
)
606 aouthdr_in
->text_start
-= ib
;
607 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
608 aouthdr_in
->text_start
&= 0xffffffff;
612 if (aouthdr_in
->dsize
)
614 aouthdr_in
->data_start
-= ib
;
615 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
616 aouthdr_in
->data_start
&= 0xffffffff;
620 if (aouthdr_in
->entry
)
622 aouthdr_in
->entry
-= ib
;
623 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
624 aouthdr_in
->entry
&= 0xffffffff;
628 #define FA(x) (((x) + fa -1 ) & (- fa))
629 #define SA(x) (((x) + sa -1 ) & (- sa))
631 /* We like to have the sizes aligned. */
632 aouthdr_in
->bsize
= FA (aouthdr_in
->bsize
);
634 extra
->NumberOfRvaAndSizes
= IMAGE_NUMBEROF_DIRECTORY_ENTRIES
;
636 add_data_entry (abfd
, extra
, PE_EXPORT_TABLE
, ".edata", ib
);
637 add_data_entry (abfd
, extra
, PE_RESOURCE_TABLE
, ".rsrc", ib
);
638 add_data_entry (abfd
, extra
, PE_EXCEPTION_TABLE
, ".pdata", ib
);
640 /* In theory we do not need to call add_data_entry for .idata$2 or
641 .idata$5. It will be done in bfd_coff_final_link where all the
642 required information is available. If however, we are not going
643 to perform a final link, eg because we have been invoked by objcopy
644 or strip, then we need to make sure that these Data Directory
645 entries are initialised properly.
647 So - we copy the input values into the output values, and then, if
648 a final link is going to be performed, it can overwrite them. */
649 extra
->DataDirectory
[PE_IMPORT_TABLE
] = idata2
;
650 extra
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
] = idata5
;
651 extra
->DataDirectory
[PE_TLS_TABLE
] = tls
;
653 if (extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
== 0)
654 /* Until other .idata fixes are made (pending patch), the entry for
655 .idata is needed for backwards compatibility. FIXME. */
656 add_data_entry (abfd
, extra
, PE_IMPORT_TABLE
, ".idata", ib
);
658 /* For some reason, the virtual size (which is what's set by
659 add_data_entry) for .reloc is not the same as the size recorded
660 in this slot by MSVC; it doesn't seem to cause problems (so far),
661 but since it's the best we've got, use it. It does do the right
663 if (pe
->has_reloc_section
)
664 add_data_entry (abfd
, extra
, PE_BASE_RELOCATION_TABLE
, ".reloc", ib
);
673 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
675 int rounded
= FA (sec
->size
);
680 /* The first non-zero section filepos is the header size.
681 Sections without contents will have a filepos of 0. */
683 hsize
= sec
->filepos
;
684 if (sec
->flags
& SEC_DATA
)
686 if (sec
->flags
& SEC_CODE
)
688 /* The image size is the total VIRTUAL size (which is what is
689 in the virt_size field). Files have been seen (from MSVC
690 5.0 link.exe) where the file size of the .data segment is
691 quite small compared to the virtual size. Without this
692 fix, strip munges the file.
694 FIXME: We need to handle holes between sections, which may
695 happpen when we covert from another format. We just use
696 the virtual address and virtual size of the last section
697 for the image size. */
698 if (coff_section_data (abfd
, sec
) != NULL
699 && pei_section_data (abfd
, sec
) != NULL
)
700 isize
= (sec
->vma
- extra
->ImageBase
701 + SA (FA (pei_section_data (abfd
, sec
)->virt_size
)));
704 aouthdr_in
->dsize
= dsize
;
705 aouthdr_in
->tsize
= tsize
;
706 extra
->SizeOfHeaders
= hsize
;
707 extra
->SizeOfImage
= isize
;
710 H_PUT_16 (abfd
, aouthdr_in
->magic
, aouthdr_out
->standard
.magic
);
712 if (extra
->MajorLinkerVersion
|| extra
->MinorLinkerVersion
)
714 H_PUT_8 (abfd
, extra
->MajorLinkerVersion
,
715 aouthdr_out
->standard
.vstamp
);
716 H_PUT_8 (abfd
, extra
->MinorLinkerVersion
,
717 aouthdr_out
->standard
.vstamp
+ 1);
721 /* e.g. 219510000 is linker version 2.19 */
722 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
724 /* This piece of magic sets the "linker version" field to
726 H_PUT_16 (abfd
, (LINKER_VERSION
/ 100 + (LINKER_VERSION
% 100) * 256),
727 aouthdr_out
->standard
.vstamp
);
730 PUT_AOUTHDR_TSIZE (abfd
, aouthdr_in
->tsize
, aouthdr_out
->standard
.tsize
);
731 PUT_AOUTHDR_DSIZE (abfd
, aouthdr_in
->dsize
, aouthdr_out
->standard
.dsize
);
732 PUT_AOUTHDR_BSIZE (abfd
, aouthdr_in
->bsize
, aouthdr_out
->standard
.bsize
);
733 PUT_AOUTHDR_ENTRY (abfd
, aouthdr_in
->entry
, aouthdr_out
->standard
.entry
);
734 PUT_AOUTHDR_TEXT_START (abfd
, aouthdr_in
->text_start
,
735 aouthdr_out
->standard
.text_start
);
737 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
738 /* PE32+ does not have data_start member! */
739 PUT_AOUTHDR_DATA_START (abfd
, aouthdr_in
->data_start
,
740 aouthdr_out
->standard
.data_start
);
743 PUT_OPTHDR_IMAGE_BASE (abfd
, extra
->ImageBase
, aouthdr_out
->ImageBase
);
744 H_PUT_32 (abfd
, extra
->SectionAlignment
, aouthdr_out
->SectionAlignment
);
745 H_PUT_32 (abfd
, extra
->FileAlignment
, aouthdr_out
->FileAlignment
);
746 H_PUT_16 (abfd
, extra
->MajorOperatingSystemVersion
,
747 aouthdr_out
->MajorOperatingSystemVersion
);
748 H_PUT_16 (abfd
, extra
->MinorOperatingSystemVersion
,
749 aouthdr_out
->MinorOperatingSystemVersion
);
750 H_PUT_16 (abfd
, extra
->MajorImageVersion
, aouthdr_out
->MajorImageVersion
);
751 H_PUT_16 (abfd
, extra
->MinorImageVersion
, aouthdr_out
->MinorImageVersion
);
752 H_PUT_16 (abfd
, extra
->MajorSubsystemVersion
,
753 aouthdr_out
->MajorSubsystemVersion
);
754 H_PUT_16 (abfd
, extra
->MinorSubsystemVersion
,
755 aouthdr_out
->MinorSubsystemVersion
);
756 H_PUT_32 (abfd
, extra
->Reserved1
, aouthdr_out
->Reserved1
);
757 H_PUT_32 (abfd
, extra
->SizeOfImage
, aouthdr_out
->SizeOfImage
);
758 H_PUT_32 (abfd
, extra
->SizeOfHeaders
, aouthdr_out
->SizeOfHeaders
);
759 H_PUT_32 (abfd
, extra
->CheckSum
, aouthdr_out
->CheckSum
);
760 H_PUT_16 (abfd
, extra
->Subsystem
, aouthdr_out
->Subsystem
);
761 H_PUT_16 (abfd
, extra
->DllCharacteristics
, aouthdr_out
->DllCharacteristics
);
762 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd
, extra
->SizeOfStackReserve
,
763 aouthdr_out
->SizeOfStackReserve
);
764 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd
, extra
->SizeOfStackCommit
,
765 aouthdr_out
->SizeOfStackCommit
);
766 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd
, extra
->SizeOfHeapReserve
,
767 aouthdr_out
->SizeOfHeapReserve
);
768 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd
, extra
->SizeOfHeapCommit
,
769 aouthdr_out
->SizeOfHeapCommit
);
770 H_PUT_32 (abfd
, extra
->LoaderFlags
, aouthdr_out
->LoaderFlags
);
771 H_PUT_32 (abfd
, extra
->NumberOfRvaAndSizes
,
772 aouthdr_out
->NumberOfRvaAndSizes
);
776 for (idx
= 0; idx
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; idx
++)
778 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].VirtualAddress
,
779 aouthdr_out
->DataDirectory
[idx
][0]);
780 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].Size
,
781 aouthdr_out
->DataDirectory
[idx
][1]);
789 _bfd_XXi_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
792 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
793 struct external_PEI_filehdr
*filehdr_out
= (struct external_PEI_filehdr
*) out
;
795 if (pe_data (abfd
)->has_reloc_section
796 || pe_data (abfd
)->dont_strip_reloc
)
797 filehdr_in
->f_flags
&= ~F_RELFLG
;
799 if (pe_data (abfd
)->dll
)
800 filehdr_in
->f_flags
|= F_DLL
;
802 filehdr_in
->pe
.e_magic
= IMAGE_DOS_SIGNATURE
;
803 filehdr_in
->pe
.e_cblp
= 0x90;
804 filehdr_in
->pe
.e_cp
= 0x3;
805 filehdr_in
->pe
.e_crlc
= 0x0;
806 filehdr_in
->pe
.e_cparhdr
= 0x4;
807 filehdr_in
->pe
.e_minalloc
= 0x0;
808 filehdr_in
->pe
.e_maxalloc
= 0xffff;
809 filehdr_in
->pe
.e_ss
= 0x0;
810 filehdr_in
->pe
.e_sp
= 0xb8;
811 filehdr_in
->pe
.e_csum
= 0x0;
812 filehdr_in
->pe
.e_ip
= 0x0;
813 filehdr_in
->pe
.e_cs
= 0x0;
814 filehdr_in
->pe
.e_lfarlc
= 0x40;
815 filehdr_in
->pe
.e_ovno
= 0x0;
817 for (idx
= 0; idx
< 4; idx
++)
818 filehdr_in
->pe
.e_res
[idx
] = 0x0;
820 filehdr_in
->pe
.e_oemid
= 0x0;
821 filehdr_in
->pe
.e_oeminfo
= 0x0;
823 for (idx
= 0; idx
< 10; idx
++)
824 filehdr_in
->pe
.e_res2
[idx
] = 0x0;
826 filehdr_in
->pe
.e_lfanew
= 0x80;
828 /* This next collection of data are mostly just characters. It
829 appears to be constant within the headers put on NT exes. */
830 memcpy (filehdr_in
->pe
.dos_message
, pe_data (abfd
)->dos_message
,
831 sizeof (filehdr_in
->pe
.dos_message
));
833 filehdr_in
->pe
.nt_signature
= IMAGE_NT_SIGNATURE
;
835 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
836 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
838 /* Use a real timestamp by default, unless the no-insert-timestamp
839 option was chosen. */
840 if ((pe_data (abfd
)->timestamp
) == -1)
843 char *source_date_epoch
;
845 /* If the SOURCE_DATE_EPOCH environment variable is
846 defined then use that as the time, otherwise use
848 source_date_epoch
= getenv ("SOURCE_DATE_EPOCH");
849 if (source_date_epoch
)
850 now
= (time_t) strtoll (source_date_epoch
, NULL
, 10);
853 H_PUT_32 (abfd
, now
, filehdr_out
->f_timdat
);
856 H_PUT_32 (abfd
, pe_data (abfd
)->timestamp
, filehdr_out
->f_timdat
);
858 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
859 filehdr_out
->f_symptr
);
860 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
861 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
862 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
864 /* Put in extra dos header stuff. This data remains essentially
865 constant, it just has to be tacked on to the beginning of all exes
867 H_PUT_16 (abfd
, filehdr_in
->pe
.e_magic
, filehdr_out
->e_magic
);
868 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cblp
, filehdr_out
->e_cblp
);
869 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cp
, filehdr_out
->e_cp
);
870 H_PUT_16 (abfd
, filehdr_in
->pe
.e_crlc
, filehdr_out
->e_crlc
);
871 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cparhdr
, filehdr_out
->e_cparhdr
);
872 H_PUT_16 (abfd
, filehdr_in
->pe
.e_minalloc
, filehdr_out
->e_minalloc
);
873 H_PUT_16 (abfd
, filehdr_in
->pe
.e_maxalloc
, filehdr_out
->e_maxalloc
);
874 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ss
, filehdr_out
->e_ss
);
875 H_PUT_16 (abfd
, filehdr_in
->pe
.e_sp
, filehdr_out
->e_sp
);
876 H_PUT_16 (abfd
, filehdr_in
->pe
.e_csum
, filehdr_out
->e_csum
);
877 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ip
, filehdr_out
->e_ip
);
878 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cs
, filehdr_out
->e_cs
);
879 H_PUT_16 (abfd
, filehdr_in
->pe
.e_lfarlc
, filehdr_out
->e_lfarlc
);
880 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ovno
, filehdr_out
->e_ovno
);
882 for (idx
= 0; idx
< 4; idx
++)
883 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res
[idx
], filehdr_out
->e_res
[idx
]);
885 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oemid
, filehdr_out
->e_oemid
);
886 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oeminfo
, filehdr_out
->e_oeminfo
);
888 for (idx
= 0; idx
< 10; idx
++)
889 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res2
[idx
], filehdr_out
->e_res2
[idx
]);
891 H_PUT_32 (abfd
, filehdr_in
->pe
.e_lfanew
, filehdr_out
->e_lfanew
);
893 for (idx
= 0; idx
< 16; idx
++)
894 H_PUT_32 (abfd
, filehdr_in
->pe
.dos_message
[idx
],
895 filehdr_out
->dos_message
[idx
]);
897 /* Also put in the NT signature. */
898 H_PUT_32 (abfd
, filehdr_in
->pe
.nt_signature
, filehdr_out
->nt_signature
);
904 _bfd_XX_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
906 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
907 FILHDR
*filehdr_out
= (FILHDR
*) out
;
909 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
910 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
911 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->f_timdat
);
912 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
, filehdr_out
->f_symptr
);
913 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
914 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
915 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
921 _bfd_XXi_swap_scnhdr_out (bfd
* abfd
, void * in
, void * out
)
923 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*) in
;
924 SCNHDR
*scnhdr_ext
= (SCNHDR
*) out
;
925 unsigned int ret
= SCNHSZ
;
929 memcpy (scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof (scnhdr_int
->s_name
));
931 ss
= scnhdr_int
->s_vaddr
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
932 if (scnhdr_int
->s_vaddr
< pe_data (abfd
)->pe_opthdr
.ImageBase
)
933 _bfd_error_handler (_("%pB:%.8s: section below image base"),
934 abfd
, scnhdr_int
->s_name
);
935 /* Do not compare lower 32-bits for 64-bit vma. */
936 #if !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
937 else if(ss
!= (ss
& 0xffffffff))
938 _bfd_error_handler (_("%pB:%.8s: RVA truncated"), abfd
, scnhdr_int
->s_name
);
939 PUT_SCNHDR_VADDR (abfd
, ss
& 0xffffffff, scnhdr_ext
->s_vaddr
);
941 PUT_SCNHDR_VADDR (abfd
, ss
, scnhdr_ext
->s_vaddr
);
944 /* NT wants the size data to be rounded up to the next
945 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
947 if ((scnhdr_int
->s_flags
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
) != 0)
949 if (bfd_pei_p (abfd
))
951 ps
= scnhdr_int
->s_size
;
957 ss
= scnhdr_int
->s_size
;
962 if (bfd_pei_p (abfd
))
963 ps
= scnhdr_int
->s_paddr
;
967 ss
= scnhdr_int
->s_size
;
970 PUT_SCNHDR_SIZE (abfd
, ss
,
973 /* s_paddr in PE is really the virtual size. */
974 PUT_SCNHDR_PADDR (abfd
, ps
, scnhdr_ext
->s_paddr
);
976 PUT_SCNHDR_SCNPTR (abfd
, scnhdr_int
->s_scnptr
,
977 scnhdr_ext
->s_scnptr
);
978 PUT_SCNHDR_RELPTR (abfd
, scnhdr_int
->s_relptr
,
979 scnhdr_ext
->s_relptr
);
980 PUT_SCNHDR_LNNOPTR (abfd
, scnhdr_int
->s_lnnoptr
,
981 scnhdr_ext
->s_lnnoptr
);
984 /* Extra flags must be set when dealing with PE. All sections should also
985 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
986 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
987 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
988 (this is especially important when dealing with the .idata section since
989 the addresses for routines from .dlls must be overwritten). If .reloc
990 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
991 (0x02000000). Also, the resource data should also be read and
994 /* FIXME: Alignment is also encoded in this field, at least on
995 ARM-WINCE. Although - how do we get the original alignment field
1000 char section_name
[SCNNMLEN
];
1001 unsigned long must_have
;
1003 pe_required_section_flags
;
1005 pe_required_section_flags known_sections
[] =
1007 { ".arch", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
| IMAGE_SCN_ALIGN_8BYTES
},
1008 { ".bss", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1009 { ".data", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1010 { ".edata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1011 { ".idata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1012 { ".pdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1013 { ".rdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1014 { ".reloc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
},
1015 { ".rsrc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1016 { ".text" , IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_CODE
| IMAGE_SCN_MEM_EXECUTE
},
1017 { ".tls", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1018 { ".xdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1021 pe_required_section_flags
* p
;
1023 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1024 we know exactly what this specific section wants so we remove it
1025 and then allow the must_have field to add it back in if necessary.
1026 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1027 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
1028 by ld --enable-auto-import (if auto-import is actually needed),
1029 by ld --omagic, or by obcopy --writable-text. */
1031 for (p
= known_sections
;
1032 p
< known_sections
+ ARRAY_SIZE (known_sections
);
1034 if (memcmp (scnhdr_int
->s_name
, p
->section_name
, SCNNMLEN
) == 0)
1036 if (memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text")
1037 || (bfd_get_file_flags (abfd
) & WP_TEXT
))
1038 scnhdr_int
->s_flags
&= ~IMAGE_SCN_MEM_WRITE
;
1039 scnhdr_int
->s_flags
|= p
->must_have
;
1043 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1046 if (coff_data (abfd
)->link_info
1047 && ! bfd_link_relocatable (coff_data (abfd
)->link_info
)
1048 && ! bfd_link_pic (coff_data (abfd
)->link_info
)
1049 && memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text") == 0)
1051 /* By inference from looking at MS output, the 32 bit field
1052 which is the combination of the number_of_relocs and
1053 number_of_linenos is used for the line number count in
1054 executables. A 16-bit field won't do for cc1. The MS
1055 document says that the number of relocs is zero for
1056 executables, but the 17-th bit has been observed to be there.
1057 Overflow is not an issue: a 4G-line program will overflow a
1058 bunch of other fields long before this! */
1059 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
& 0xffff), scnhdr_ext
->s_nlnno
);
1060 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
>> 16), scnhdr_ext
->s_nreloc
);
1064 if (scnhdr_int
->s_nlnno
<= 0xffff)
1065 H_PUT_16 (abfd
, scnhdr_int
->s_nlnno
, scnhdr_ext
->s_nlnno
);
1068 /* xgettext:c-format */
1069 _bfd_error_handler (_("%pB: line number overflow: 0x%lx > 0xffff"),
1070 abfd
, scnhdr_int
->s_nlnno
);
1071 bfd_set_error (bfd_error_file_truncated
);
1072 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nlnno
);
1076 /* Although we could encode 0xffff relocs here, we do not, to be
1077 consistent with other parts of bfd. Also it lets us warn, as
1078 we should never see 0xffff here w/o having the overflow flag
1080 if (scnhdr_int
->s_nreloc
< 0xffff)
1081 H_PUT_16 (abfd
, scnhdr_int
->s_nreloc
, scnhdr_ext
->s_nreloc
);
1084 /* PE can deal with large #s of relocs, but not here. */
1085 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nreloc
);
1086 scnhdr_int
->s_flags
|= IMAGE_SCN_LNK_NRELOC_OVFL
;
1087 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1094 _bfd_XXi_swap_debugdir_in (bfd
* abfd
, void * ext1
, void * in1
)
1096 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) ext1
;
1097 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) in1
;
1099 in
->Characteristics
= H_GET_32(abfd
, ext
->Characteristics
);
1100 in
->TimeDateStamp
= H_GET_32(abfd
, ext
->TimeDateStamp
);
1101 in
->MajorVersion
= H_GET_16(abfd
, ext
->MajorVersion
);
1102 in
->MinorVersion
= H_GET_16(abfd
, ext
->MinorVersion
);
1103 in
->Type
= H_GET_32(abfd
, ext
->Type
);
1104 in
->SizeOfData
= H_GET_32(abfd
, ext
->SizeOfData
);
1105 in
->AddressOfRawData
= H_GET_32(abfd
, ext
->AddressOfRawData
);
1106 in
->PointerToRawData
= H_GET_32(abfd
, ext
->PointerToRawData
);
1110 _bfd_XXi_swap_debugdir_out (bfd
* abfd
, void * inp
, void * extp
)
1112 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) extp
;
1113 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) inp
;
1115 H_PUT_32(abfd
, in
->Characteristics
, ext
->Characteristics
);
1116 H_PUT_32(abfd
, in
->TimeDateStamp
, ext
->TimeDateStamp
);
1117 H_PUT_16(abfd
, in
->MajorVersion
, ext
->MajorVersion
);
1118 H_PUT_16(abfd
, in
->MinorVersion
, ext
->MinorVersion
);
1119 H_PUT_32(abfd
, in
->Type
, ext
->Type
);
1120 H_PUT_32(abfd
, in
->SizeOfData
, ext
->SizeOfData
);
1121 H_PUT_32(abfd
, in
->AddressOfRawData
, ext
->AddressOfRawData
);
1122 H_PUT_32(abfd
, in
->PointerToRawData
, ext
->PointerToRawData
);
1124 return sizeof (struct external_IMAGE_DEBUG_DIRECTORY
);
1128 _bfd_XXi_slurp_codeview_record (bfd
* abfd
, file_ptr where
, unsigned long length
, CODEVIEW_INFO
*cvinfo
,
1132 bfd_size_type nread
;
1134 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1137 if (length
<= sizeof (CV_INFO_PDB70
) && length
<= sizeof (CV_INFO_PDB20
))
1141 nread
= bfd_bread (buffer
, length
, abfd
);
1142 if (length
!= nread
)
1145 /* Ensure null termination of filename. */
1146 memset (buffer
+ nread
, 0, sizeof (buffer
) - nread
);
1148 cvinfo
->CVSignature
= H_GET_32 (abfd
, buffer
);
1151 if ((cvinfo
->CVSignature
== CVINFO_PDB70_CVSIGNATURE
)
1152 && (length
> sizeof (CV_INFO_PDB70
)))
1154 CV_INFO_PDB70
*cvinfo70
= (CV_INFO_PDB70
*)(buffer
);
1156 cvinfo
->Age
= H_GET_32(abfd
, cvinfo70
->Age
);
1158 /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1159 by 8 single bytes. Byte swap them so we can conveniently treat the GUID
1160 as 16 bytes in big-endian order. */
1161 bfd_putb32 (bfd_getl32 (cvinfo70
->Signature
), cvinfo
->Signature
);
1162 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[4])), &(cvinfo
->Signature
[4]));
1163 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[6])), &(cvinfo
->Signature
[6]));
1164 memcpy (&(cvinfo
->Signature
[8]), &(cvinfo70
->Signature
[8]), 8);
1166 cvinfo
->SignatureLength
= CV_INFO_SIGNATURE_LENGTH
;
1167 /* cvinfo->PdbFileName = cvinfo70->PdbFileName; */
1170 *pdb
= xstrdup (cvinfo70
->PdbFileName
);
1174 else if ((cvinfo
->CVSignature
== CVINFO_PDB20_CVSIGNATURE
)
1175 && (length
> sizeof (CV_INFO_PDB20
)))
1177 CV_INFO_PDB20
*cvinfo20
= (CV_INFO_PDB20
*)(buffer
);
1178 cvinfo
->Age
= H_GET_32(abfd
, cvinfo20
->Age
);
1179 memcpy (cvinfo
->Signature
, cvinfo20
->Signature
, 4);
1180 cvinfo
->SignatureLength
= 4;
1181 /* cvinfo->PdbFileName = cvinfo20->PdbFileName; */
1184 *pdb
= xstrdup (cvinfo20
->PdbFileName
);
1193 _bfd_XXi_write_codeview_record (bfd
* abfd
, file_ptr where
, CODEVIEW_INFO
*cvinfo
,
1196 size_t pdb_len
= pdb
? strlen (pdb
) : 0;
1197 const bfd_size_type size
= sizeof (CV_INFO_PDB70
) + pdb_len
+ 1;
1198 bfd_size_type written
;
1199 CV_INFO_PDB70
*cvinfo70
;
1202 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1205 buffer
= bfd_malloc (size
);
1209 cvinfo70
= (CV_INFO_PDB70
*) buffer
;
1210 H_PUT_32 (abfd
, CVINFO_PDB70_CVSIGNATURE
, cvinfo70
->CvSignature
);
1212 /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1213 in little-endian order, followed by 8 single bytes. */
1214 bfd_putl32 (bfd_getb32 (cvinfo
->Signature
), cvinfo70
->Signature
);
1215 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[4])), &(cvinfo70
->Signature
[4]));
1216 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[6])), &(cvinfo70
->Signature
[6]));
1217 memcpy (&(cvinfo70
->Signature
[8]), &(cvinfo
->Signature
[8]), 8);
1219 H_PUT_32 (abfd
, cvinfo
->Age
, cvinfo70
->Age
);
1222 cvinfo70
->PdbFileName
[0] = '\0';
1224 memcpy (cvinfo70
->PdbFileName
, pdb
, pdb_len
+ 1);
1226 written
= bfd_bwrite (buffer
, size
, abfd
);
1230 return written
== size
? size
: 0;
1233 static char * dir_names
[IMAGE_NUMBEROF_DIRECTORY_ENTRIES
] =
1235 N_("Export Directory [.edata (or where ever we found it)]"),
1236 N_("Import Directory [parts of .idata]"),
1237 N_("Resource Directory [.rsrc]"),
1238 N_("Exception Directory [.pdata]"),
1239 N_("Security Directory"),
1240 N_("Base Relocation Directory [.reloc]"),
1241 N_("Debug Directory"),
1242 N_("Description Directory"),
1243 N_("Special Directory"),
1244 N_("Thread Storage Directory [.tls]"),
1245 N_("Load Configuration Directory"),
1246 N_("Bound Import Directory"),
1247 N_("Import Address Table Directory"),
1248 N_("Delay Import Directory"),
1249 N_("CLR Runtime Header"),
1254 get_contents_sanity_check (bfd
*abfd
, asection
*section
,
1255 bfd_size_type dataoff
, bfd_size_type datasize
)
1257 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
1259 if (dataoff
> section
->size
1260 || datasize
> section
->size
- dataoff
)
1262 ufile_ptr filesize
= bfd_get_file_size (abfd
);
1264 && ((ufile_ptr
) section
->filepos
> filesize
1265 || dataoff
> filesize
- section
->filepos
1266 || datasize
> filesize
- section
->filepos
- dataoff
))
1272 pe_print_idata (bfd
* abfd
, void * vfile
)
1274 FILE *file
= (FILE *) vfile
;
1278 bfd_size_type datasize
= 0;
1279 bfd_size_type dataoff
;
1283 pe_data_type
*pe
= pe_data (abfd
);
1284 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1288 addr
= extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
;
1290 if (addr
== 0 && extra
->DataDirectory
[PE_IMPORT_TABLE
].Size
== 0)
1292 /* Maybe the extra header isn't there. Look for the section. */
1293 section
= bfd_get_section_by_name (abfd
, ".idata");
1294 if (section
== NULL
|| (section
->flags
& SEC_HAS_CONTENTS
) == 0)
1297 addr
= section
->vma
;
1298 datasize
= section
->size
;
1304 addr
+= extra
->ImageBase
;
1305 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1307 datasize
= section
->size
;
1308 if (addr
>= section
->vma
&& addr
< section
->vma
+ datasize
)
1312 if (section
== NULL
)
1315 _("\nThere is an import table, but the section containing it could not be found\n"));
1318 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1321 _("\nThere is an import table in %s, but that section has no contents\n"),
1327 /* xgettext:c-format */
1328 fprintf (file
, _("\nThere is an import table in %s at 0x%lx\n"),
1329 section
->name
, (unsigned long) addr
);
1331 dataoff
= addr
- section
->vma
;
1334 _("\nThe Import Tables (interpreted %s section contents)\n"),
1338 vma: Hint Time Forward DLL First\n\
1339 Table Stamp Chain Name Thunk\n"));
1341 /* Read the whole section. Some of the fields might be before dataoff. */
1342 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
1348 adj
= section
->vma
- extra
->ImageBase
;
1350 /* Print all image import descriptors. */
1351 for (i
= dataoff
; i
+ onaline
<= datasize
; i
+= onaline
)
1355 bfd_vma forward_chain
;
1357 bfd_vma first_thunk
;
1362 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1363 fprintf (file
, " %08lx\t", (unsigned long) (i
+ adj
));
1364 hint_addr
= bfd_get_32 (abfd
, data
+ i
);
1365 time_stamp
= bfd_get_32 (abfd
, data
+ i
+ 4);
1366 forward_chain
= bfd_get_32 (abfd
, data
+ i
+ 8);
1367 dll_name
= bfd_get_32 (abfd
, data
+ i
+ 12);
1368 first_thunk
= bfd_get_32 (abfd
, data
+ i
+ 16);
1370 fprintf (file
, "%08lx %08lx %08lx %08lx %08lx\n",
1371 (unsigned long) hint_addr
,
1372 (unsigned long) time_stamp
,
1373 (unsigned long) forward_chain
,
1374 (unsigned long) dll_name
,
1375 (unsigned long) first_thunk
);
1377 if (hint_addr
== 0 && first_thunk
== 0)
1380 if (dll_name
- adj
>= section
->size
)
1383 dll
= (char *) data
+ dll_name
- adj
;
1384 /* PR 17512 file: 078-12277-0.004. */
1385 bfd_size_type maxlen
= (char *)(data
+ datasize
) - dll
- 1;
1386 fprintf (file
, _("\n\tDLL Name: %.*s\n"), (int) maxlen
, dll
);
1388 /* PR 21546: When the Hint Address is zero,
1389 we try the First Thunk instead. */
1391 hint_addr
= first_thunk
;
1393 if (hint_addr
!= 0 && hint_addr
- adj
< datasize
)
1396 asection
*ft_section
;
1398 bfd_size_type ft_datasize
;
1402 fprintf (file
, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1404 idx
= hint_addr
- adj
;
1406 ft_addr
= first_thunk
+ extra
->ImageBase
;
1407 ft_idx
= first_thunk
- adj
;
1408 ft_data
= data
+ ft_idx
;
1409 ft_datasize
= datasize
- ft_idx
;
1412 if (first_thunk
!= hint_addr
)
1414 /* Find the section which contains the first thunk. */
1415 for (ft_section
= abfd
->sections
;
1417 ft_section
= ft_section
->next
)
1419 if (ft_addr
>= ft_section
->vma
1420 && ft_addr
< ft_section
->vma
+ ft_section
->size
)
1424 if (ft_section
== NULL
)
1427 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1431 /* Now check to see if this section is the same as our current
1432 section. If it is not then we will have to load its data in. */
1433 if (ft_section
!= section
)
1435 ft_idx
= first_thunk
- (ft_section
->vma
- extra
->ImageBase
);
1436 ft_datasize
= ft_section
->size
- ft_idx
;
1437 if (!get_contents_sanity_check (abfd
, ft_section
,
1438 ft_idx
, ft_datasize
))
1440 ft_data
= (bfd_byte
*) bfd_malloc (ft_datasize
);
1441 if (ft_data
== NULL
)
1444 /* Read ft_datasize bytes starting at offset ft_idx. */
1445 if (!bfd_get_section_contents (abfd
, ft_section
, ft_data
,
1446 (bfd_vma
) ft_idx
, ft_datasize
))
1455 /* Print HintName vector entries. */
1456 #ifdef COFF_WITH_pex64
1457 for (j
= 0; idx
+ j
+ 8 <= datasize
; j
+= 8)
1460 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1461 unsigned long member_high
= bfd_get_32 (abfd
, data
+ idx
+ j
+ 4);
1463 if (!member
&& !member_high
)
1468 if (HighBitSet (member_high
))
1469 fprintf (file
, "\t%lx%08lx\t %4lx%08lx <none>",
1470 member_high
, member
,
1471 WithoutHighBit (member_high
), member
);
1472 /* PR binutils/17512: Handle corrupt PE data. */
1473 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1474 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1480 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1481 member_name
= (char *) data
+ amt
+ 2;
1482 fprintf (file
, "\t%04lx\t %4d %.*s",member
, ordinal
,
1483 (int) (datasize
- (amt
+ 2)), member_name
);
1486 /* If the time stamp is not zero, the import address
1487 table holds actual addresses. */
1490 && first_thunk
!= hint_addr
1491 && j
+ 4 <= ft_datasize
)
1492 fprintf (file
, "\t%04lx",
1493 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1494 fprintf (file
, "\n");
1497 for (j
= 0; idx
+ j
+ 4 <= datasize
; j
+= 4)
1500 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1502 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1508 if (HighBitSet (member
))
1509 fprintf (file
, "\t%04lx\t %4lu <none>",
1510 member
, WithoutHighBit (member
));
1511 /* PR binutils/17512: Handle corrupt PE data. */
1512 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1513 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1519 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1520 member_name
= (char *) data
+ amt
+ 2;
1521 fprintf (file
, "\t%04lx\t %4d %.*s",
1523 (int) (datasize
- (amt
+ 2)), member_name
);
1526 /* If the time stamp is not zero, the import address
1527 table holds actual addresses. */
1530 && first_thunk
!= hint_addr
1531 && j
+ 4 <= ft_datasize
)
1532 fprintf (file
, "\t%04lx",
1533 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1535 fprintf (file
, "\n");
1542 fprintf (file
, "\n");
1551 pe_print_edata (bfd
* abfd
, void * vfile
)
1553 FILE *file
= (FILE *) vfile
;
1556 bfd_size_type datasize
= 0;
1557 bfd_size_type dataoff
;
1562 long export_flags
; /* Reserved - should be zero. */
1566 bfd_vma name
; /* RVA - relative to image base. */
1567 long base
; /* Ordinal base. */
1568 unsigned long num_functions
;/* Number in the export address table. */
1569 unsigned long num_names
; /* Number in the name pointer table. */
1570 bfd_vma eat_addr
; /* RVA to the export address table. */
1571 bfd_vma npt_addr
; /* RVA to the Export Name Pointer Table. */
1572 bfd_vma ot_addr
; /* RVA to the Ordinal Table. */
1575 pe_data_type
*pe
= pe_data (abfd
);
1576 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1580 addr
= extra
->DataDirectory
[PE_EXPORT_TABLE
].VirtualAddress
;
1582 if (addr
== 0 && extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
== 0)
1584 /* Maybe the extra header isn't there. Look for the section. */
1585 section
= bfd_get_section_by_name (abfd
, ".edata");
1586 if (section
== NULL
)
1589 addr
= section
->vma
;
1591 datasize
= section
->size
;
1597 addr
+= extra
->ImageBase
;
1599 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1600 if (addr
>= section
->vma
&& addr
< section
->vma
+ section
->size
)
1603 if (section
== NULL
)
1606 _("\nThere is an export table, but the section containing it could not be found\n"));
1610 dataoff
= addr
- section
->vma
;
1611 datasize
= extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
;
1614 /* PR 17512: Handle corrupt PE binaries. */
1618 /* xgettext:c-format */
1619 _("\nThere is an export table in %s, but it is too small (%d)\n"),
1620 section
->name
, (int) datasize
);
1624 if (!get_contents_sanity_check (abfd
, section
, dataoff
, datasize
))
1627 _("\nThere is an export table in %s, but contents cannot be read\n"),
1632 /* xgettext:c-format */
1633 fprintf (file
, _("\nThere is an export table in %s at 0x%lx\n"),
1634 section
->name
, (unsigned long) addr
);
1636 data
= (bfd_byte
*) bfd_malloc (datasize
);
1640 if (! bfd_get_section_contents (abfd
, section
, data
,
1641 (file_ptr
) dataoff
, datasize
))
1647 /* Go get Export Directory Table. */
1648 edt
.export_flags
= bfd_get_32 (abfd
, data
+ 0);
1649 edt
.time_stamp
= bfd_get_32 (abfd
, data
+ 4);
1650 edt
.major_ver
= bfd_get_16 (abfd
, data
+ 8);
1651 edt
.minor_ver
= bfd_get_16 (abfd
, data
+ 10);
1652 edt
.name
= bfd_get_32 (abfd
, data
+ 12);
1653 edt
.base
= bfd_get_32 (abfd
, data
+ 16);
1654 edt
.num_functions
= bfd_get_32 (abfd
, data
+ 20);
1655 edt
.num_names
= bfd_get_32 (abfd
, data
+ 24);
1656 edt
.eat_addr
= bfd_get_32 (abfd
, data
+ 28);
1657 edt
.npt_addr
= bfd_get_32 (abfd
, data
+ 32);
1658 edt
.ot_addr
= bfd_get_32 (abfd
, data
+ 36);
1660 adj
= section
->vma
- extra
->ImageBase
+ dataoff
;
1662 /* Dump the EDT first. */
1664 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1668 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt
.export_flags
);
1671 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt
.time_stamp
);
1674 /* xgettext:c-format */
1675 _("Major/Minor \t\t\t%d/%d\n"), edt
.major_ver
, edt
.minor_ver
);
1678 _("Name \t\t\t\t"));
1679 bfd_fprintf_vma (abfd
, file
, edt
.name
);
1681 if ((edt
.name
>= adj
) && (edt
.name
< adj
+ datasize
))
1682 fprintf (file
, " %.*s\n",
1683 (int) (datasize
- (edt
.name
- adj
)),
1684 data
+ edt
.name
- adj
);
1686 fprintf (file
, "(outside .edata section)\n");
1689 _("Ordinal Base \t\t\t%ld\n"), edt
.base
);
1695 _("\tExport Address Table \t\t%08lx\n"),
1699 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt
.num_names
);
1702 _("Table Addresses\n"));
1705 _("\tExport Address Table \t\t"));
1706 bfd_fprintf_vma (abfd
, file
, edt
.eat_addr
);
1707 fprintf (file
, "\n");
1710 _("\tName Pointer Table \t\t"));
1711 bfd_fprintf_vma (abfd
, file
, edt
.npt_addr
);
1712 fprintf (file
, "\n");
1715 _("\tOrdinal Table \t\t\t"));
1716 bfd_fprintf_vma (abfd
, file
, edt
.ot_addr
);
1717 fprintf (file
, "\n");
1719 /* The next table to find is the Export Address Table. It's basically
1720 a list of pointers that either locate a function in this dll, or
1721 forward the call to another dll. Something like:
1726 } export_address_table_entry; */
1729 _("\nExport Address Table -- Ordinal Base %ld\n"),
1732 /* PR 17512: Handle corrupt PE binaries. */
1733 /* PR 17512 file: 140-165018-0.004. */
1734 if (edt
.eat_addr
- adj
>= datasize
1735 /* PR 17512: file: 092b1829 */
1736 || (edt
.num_functions
+ 1) * 4 < edt
.num_functions
1737 || edt
.eat_addr
- adj
+ (edt
.num_functions
+ 1) * 4 > datasize
)
1738 fprintf (file
, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1739 (long) edt
.eat_addr
,
1740 (long) edt
.num_functions
);
1741 else for (i
= 0; i
< edt
.num_functions
; ++i
)
1743 bfd_vma eat_member
= bfd_get_32 (abfd
,
1744 data
+ edt
.eat_addr
+ (i
* 4) - adj
);
1745 if (eat_member
== 0)
1748 if (eat_member
- adj
<= datasize
)
1750 /* This rva is to a name (forwarding function) in our section. */
1751 /* Should locate a function descriptor. */
1753 "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1755 (long) (i
+ edt
.base
),
1756 (unsigned long) eat_member
,
1758 (int)(datasize
- (eat_member
- adj
)),
1759 data
+ eat_member
- adj
);
1763 /* Should locate a function descriptor in the reldata section. */
1765 "\t[%4ld] +base[%4ld] %04lx %s\n",
1767 (long) (i
+ edt
.base
),
1768 (unsigned long) eat_member
,
1773 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1774 /* Dump them in parallel for clarity. */
1776 _("\n[Ordinal/Name Pointer] Table\n"));
1778 /* PR 17512: Handle corrupt PE binaries. */
1779 if (edt
.npt_addr
+ (edt
.num_names
* 4) - adj
>= datasize
1780 /* PR 17512: file: bb68816e. */
1781 || edt
.num_names
* 4 < edt
.num_names
1782 || (data
+ edt
.npt_addr
- adj
) < data
)
1783 /* xgettext:c-format */
1784 fprintf (file
, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1785 (long) edt
.npt_addr
,
1786 (long) edt
.num_names
);
1787 /* PR 17512: file: 140-147171-0.004. */
1788 else if (edt
.ot_addr
+ (edt
.num_names
* 2) - adj
>= datasize
1789 || data
+ edt
.ot_addr
- adj
< data
)
1790 /* xgettext:c-format */
1791 fprintf (file
, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1793 (long) edt
.num_names
);
1794 else for (i
= 0; i
< edt
.num_names
; ++i
)
1799 ord
= bfd_get_16 (abfd
, data
+ edt
.ot_addr
+ (i
* 2) - adj
);
1800 name_ptr
= bfd_get_32 (abfd
, data
+ edt
.npt_addr
+ (i
* 4) - adj
);
1802 if ((name_ptr
- adj
) >= datasize
)
1804 /* xgettext:c-format */
1805 fprintf (file
, _("\t[%4ld] <corrupt offset: %lx>\n"),
1806 (long) ord
, (long) name_ptr
);
1810 char * name
= (char *) data
+ name_ptr
- adj
;
1812 fprintf (file
, "\t[%4ld] %.*s\n", (long) ord
,
1813 (int)((char *)(data
+ datasize
) - name
), name
);
1822 /* This really is architecture dependent. On IA-64, a .pdata entry
1823 consists of three dwords containing relative virtual addresses that
1824 specify the start and end address of the code range the entry
1825 covers and the address of the corresponding unwind info data.
1827 On ARM and SH-4, a compressed PDATA structure is used :
1828 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1829 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1830 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1832 This is the version for uncompressed data. */
1835 pe_print_pdata (bfd
* abfd
, void * vfile
)
1837 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
1838 # define PDATA_ROW_SIZE (3 * 8)
1840 # define PDATA_ROW_SIZE (5 * 4)
1842 FILE *file
= (FILE *) vfile
;
1844 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1845 bfd_size_type datasize
= 0;
1847 bfd_size_type start
, stop
;
1848 int onaline
= PDATA_ROW_SIZE
;
1851 || (section
->flags
& SEC_HAS_CONTENTS
) == 0
1852 || coff_section_data (abfd
, section
) == NULL
1853 || pei_section_data (abfd
, section
) == NULL
)
1856 stop
= pei_section_data (abfd
, section
)->virt_size
;
1857 if ((stop
% onaline
) != 0)
1859 /* xgettext:c-format */
1860 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
1861 (long) stop
, onaline
);
1864 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1865 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
1867 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1870 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1871 \t\tAddress Address Handler Data Address Mask\n"));
1874 datasize
= section
->size
;
1878 /* PR 17512: file: 002-193900-0.004. */
1879 if (datasize
< stop
)
1881 /* xgettext:c-format */
1882 fprintf (file
, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"),
1883 (long) stop
, (long) datasize
);
1887 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
1895 for (i
= start
; i
< stop
; i
+= onaline
)
1901 bfd_vma prolog_end_addr
;
1902 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64)
1906 if (i
+ PDATA_ROW_SIZE
> stop
)
1909 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
1910 end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
1911 eh_handler
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 8);
1912 eh_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 12);
1913 prolog_end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 16);
1915 if (begin_addr
== 0 && end_addr
== 0 && eh_handler
== 0
1916 && eh_data
== 0 && prolog_end_addr
== 0)
1917 /* We are probably into the padding of the section now. */
1920 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64)
1921 em_data
= ((eh_handler
& 0x1) << 2) | (prolog_end_addr
& 0x3);
1923 eh_handler
&= ~(bfd_vma
) 0x3;
1924 prolog_end_addr
&= ~(bfd_vma
) 0x3;
1927 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
1928 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
1929 bfd_fprintf_vma (abfd
, file
, end_addr
); fputc (' ', file
);
1930 bfd_fprintf_vma (abfd
, file
, eh_handler
);
1931 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64)
1933 bfd_fprintf_vma (abfd
, file
, eh_data
); fputc (' ', file
);
1934 bfd_fprintf_vma (abfd
, file
, prolog_end_addr
);
1935 fprintf (file
, " %x", em_data
);
1937 fprintf (file
, "\n");
1943 #undef PDATA_ROW_SIZE
1946 typedef struct sym_cache
1953 slurp_symtab (bfd
*abfd
, sym_cache
*psc
)
1955 asymbol
** sy
= NULL
;
1958 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1964 storage
= bfd_get_symtab_upper_bound (abfd
);
1969 sy
= (asymbol
**) bfd_malloc (storage
);
1974 psc
->symcount
= bfd_canonicalize_symtab (abfd
, sy
);
1975 if (psc
->symcount
< 0)
1981 my_symbol_for_address (bfd
*abfd
, bfd_vma func
, sym_cache
*psc
)
1986 psc
->syms
= slurp_symtab (abfd
, psc
);
1988 for (i
= 0; i
< psc
->symcount
; i
++)
1990 if (psc
->syms
[i
]->section
->vma
+ psc
->syms
[i
]->value
== func
)
1991 return psc
->syms
[i
]->name
;
1998 cleanup_syms (sym_cache
*psc
)
2005 /* This is the version for "compressed" pdata. */
2008 _bfd_XX_print_ce_compressed_pdata (bfd
* abfd
, void * vfile
)
2010 # define PDATA_ROW_SIZE (2 * 4)
2011 FILE *file
= (FILE *) vfile
;
2012 bfd_byte
*data
= NULL
;
2013 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
2014 bfd_size_type datasize
= 0;
2016 bfd_size_type start
, stop
;
2017 int onaline
= PDATA_ROW_SIZE
;
2018 struct sym_cache cache
= {0, 0} ;
2021 || (section
->flags
& SEC_HAS_CONTENTS
) == 0
2022 || coff_section_data (abfd
, section
) == NULL
2023 || pei_section_data (abfd
, section
) == NULL
)
2026 stop
= pei_section_data (abfd
, section
)->virt_size
;
2027 if ((stop
% onaline
) != 0)
2029 /* xgettext:c-format */
2030 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
2031 (long) stop
, onaline
);
2034 _("\nThe Function Table (interpreted .pdata section contents)\n"));
2037 vma:\t\tBegin Prolog Function Flags Exception EH\n\
2038 \t\tAddress Length Length 32b exc Handler Data\n"));
2040 datasize
= section
->size
;
2044 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2051 if (stop
> datasize
)
2054 for (i
= start
; i
< stop
; i
+= onaline
)
2058 bfd_vma prolog_length
, function_length
;
2059 int flag32bit
, exception_flag
;
2062 if (i
+ PDATA_ROW_SIZE
> stop
)
2065 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
2066 other_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
2068 if (begin_addr
== 0 && other_data
== 0)
2069 /* We are probably into the padding of the section now. */
2072 prolog_length
= (other_data
& 0x000000FF);
2073 function_length
= (other_data
& 0x3FFFFF00) >> 8;
2074 flag32bit
= (int)((other_data
& 0x40000000) >> 30);
2075 exception_flag
= (int)((other_data
& 0x80000000) >> 31);
2078 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
2079 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
2080 bfd_fprintf_vma (abfd
, file
, prolog_length
); fputc (' ', file
);
2081 bfd_fprintf_vma (abfd
, file
, function_length
); fputc (' ', file
);
2082 fprintf (file
, "%2d %2d ", flag32bit
, exception_flag
);
2084 /* Get the exception handler's address and the data passed from the
2085 .text section. This is really the data that belongs with the .pdata
2086 but got "compressed" out for the ARM and SH4 architectures. */
2087 tsection
= bfd_get_section_by_name (abfd
, ".text");
2088 if (tsection
&& coff_section_data (abfd
, tsection
)
2089 && pei_section_data (abfd
, tsection
))
2091 bfd_vma eh_off
= (begin_addr
- 8) - tsection
->vma
;
2094 tdata
= (bfd_byte
*) bfd_malloc (8);
2097 if (bfd_get_section_contents (abfd
, tsection
, tdata
, eh_off
, 8))
2099 bfd_vma eh
, eh_data
;
2101 eh
= bfd_get_32 (abfd
, tdata
);
2102 eh_data
= bfd_get_32 (abfd
, tdata
+ 4);
2103 fprintf (file
, "%08x ", (unsigned int) eh
);
2104 fprintf (file
, "%08x", (unsigned int) eh_data
);
2107 const char *s
= my_symbol_for_address (abfd
, eh
, &cache
);
2110 fprintf (file
, " (%s) ", s
);
2117 fprintf (file
, "\n");
2122 cleanup_syms (& cache
);
2125 #undef PDATA_ROW_SIZE
2129 #define IMAGE_REL_BASED_HIGHADJ 4
2130 static const char * const tbl
[] =
2144 "UNKNOWN", /* MUST be last. */
2148 pe_print_reloc (bfd
* abfd
, void * vfile
)
2150 FILE *file
= (FILE *) vfile
;
2152 asection
*section
= bfd_get_section_by_name (abfd
, ".reloc");
2156 || section
->size
== 0
2157 || (section
->flags
& SEC_HAS_CONTENTS
) == 0)
2161 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2163 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2170 end
= data
+ section
->size
;
2171 while (p
+ 8 <= end
)
2174 bfd_vma virtual_address
;
2175 unsigned long number
, size
;
2176 bfd_byte
*chunk_end
;
2178 /* The .reloc section is a sequence of blocks, with a header consisting
2179 of two 32 bit quantities, followed by a number of 16 bit entries. */
2180 virtual_address
= bfd_get_32 (abfd
, p
);
2181 size
= bfd_get_32 (abfd
, p
+ 4);
2183 number
= (size
- 8) / 2;
2189 /* xgettext:c-format */
2190 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2191 (unsigned long) virtual_address
, size
, size
, number
);
2193 chunk_end
= p
- 8 + size
;
2194 if (chunk_end
> end
)
2197 while (p
+ 2 <= chunk_end
)
2199 unsigned short e
= bfd_get_16 (abfd
, p
);
2200 unsigned int t
= (e
& 0xF000) >> 12;
2201 int off
= e
& 0x0FFF;
2203 if (t
>= sizeof (tbl
) / sizeof (tbl
[0]))
2204 t
= (sizeof (tbl
) / sizeof (tbl
[0])) - 1;
2207 /* xgettext:c-format */
2208 _("\treloc %4d offset %4x [%4lx] %s"),
2209 j
, off
, (unsigned long) (off
+ virtual_address
), tbl
[t
]);
2214 /* HIGHADJ takes an argument, - the next record *is* the
2215 low 16 bits of addend. */
2216 if (t
== IMAGE_REL_BASED_HIGHADJ
&& p
+ 2 <= chunk_end
)
2218 fprintf (file
, " (%4x)", (unsigned int) bfd_get_16 (abfd
, p
));
2223 fprintf (file
, "\n");
2232 /* A data structure describing the regions of a .rsrc section.
2233 Some fields are filled in as the section is parsed. */
2235 typedef struct rsrc_regions
2237 bfd_byte
* section_start
;
2238 bfd_byte
* section_end
;
2239 bfd_byte
* strings_start
;
2240 bfd_byte
* resource_start
;
2244 rsrc_print_resource_directory (FILE * , bfd
*, unsigned int, bfd_byte
*,
2245 rsrc_regions
*, bfd_vma
);
2247 /* Print the resource entry at DATA, with the text indented by INDENT.
2248 Recusively calls rsrc_print_resource_directory to print the contents
2249 of directory entries.
2250 Returns the address of the end of the data associated with the entry
2251 or section_end + 1 upon failure. */
2254 rsrc_print_resource_entries (FILE *file
,
2256 unsigned int indent
,
2259 rsrc_regions
*regions
,
2262 unsigned long entry
, addr
, size
;
2265 if (data
+ 8 >= regions
->section_end
)
2266 return regions
->section_end
+ 1;
2268 /* xgettext:c-format */
2269 fprintf (file
, _("%03x %*.s Entry: "), (int)(data
- regions
->section_start
), indent
, " ");
2271 entry
= (unsigned long) bfd_get_32 (abfd
, data
);
2276 /* Note - the documentation says that this field is an RVA value
2277 but windres appears to produce a section relative offset with
2278 the top bit set. Support both styles for now. */
2279 if (HighBitSet (entry
))
2280 name
= regions
->section_start
+ WithoutHighBit (entry
);
2282 name
= regions
->section_start
+ entry
- rva_bias
;
2284 if (name
+ 2 < regions
->section_end
&& name
> regions
->section_start
)
2288 if (regions
->strings_start
== NULL
)
2289 regions
->strings_start
= name
;
2291 len
= bfd_get_16 (abfd
, name
);
2293 fprintf (file
, _("name: [val: %08lx len %d]: "), entry
, len
);
2295 if (name
+ 2 + len
* 2 < regions
->section_end
)
2297 /* This strange loop is to cope with multibyte characters. */
2304 /* Avoid printing control characters. */
2305 if (c
> 0 && c
< 32)
2306 fprintf (file
, "^%c", c
+ 64);
2308 fprintf (file
, "%.1s", name
);
2313 fprintf (file
, _("<corrupt string length: %#x>\n"), len
);
2314 /* PR binutils/17512: Do not try to continue decoding a
2315 corrupted resource section. It is likely to end up with
2316 reams of extraneous output. FIXME: We could probably
2317 continue if we disable the printing of strings... */
2318 return regions
->section_end
+ 1;
2323 fprintf (file
, _("<corrupt string offset: %#lx>\n"), entry
);
2324 return regions
->section_end
+ 1;
2328 fprintf (file
, _("ID: %#08lx"), entry
);
2330 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
2331 fprintf (file
, _(", Value: %#08lx\n"), entry
);
2333 if (HighBitSet (entry
))
2335 data
= regions
->section_start
+ WithoutHighBit (entry
);
2336 if (data
<= regions
->section_start
|| data
> regions
->section_end
)
2337 return regions
->section_end
+ 1;
2339 /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2340 in the resource table. We need some way to detect this. */
2341 return rsrc_print_resource_directory (file
, abfd
, indent
+ 1, data
,
2345 leaf
= regions
->section_start
+ entry
;
2347 if (leaf
+ 16 >= regions
->section_end
2348 /* PR 17512: file: 055dff7e. */
2349 || leaf
< regions
->section_start
)
2350 return regions
->section_end
+ 1;
2352 /* xgettext:c-format */
2353 fprintf (file
, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2354 (int) (entry
), indent
, " ",
2355 addr
= (long) bfd_get_32 (abfd
, leaf
),
2356 size
= (long) bfd_get_32 (abfd
, leaf
+ 4),
2357 (int) bfd_get_32 (abfd
, leaf
+ 8));
2359 /* Check that the reserved entry is 0. */
2360 if (bfd_get_32 (abfd
, leaf
+ 12) != 0
2361 /* And that the data address/size is valid too. */
2362 || (regions
->section_start
+ (addr
- rva_bias
) + size
> regions
->section_end
))
2363 return regions
->section_end
+ 1;
2365 if (regions
->resource_start
== NULL
)
2366 regions
->resource_start
= regions
->section_start
+ (addr
- rva_bias
);
2368 return regions
->section_start
+ (addr
- rva_bias
) + size
;
2371 #define max(a,b) ((a) > (b) ? (a) : (b))
2372 #define min(a,b) ((a) < (b) ? (a) : (b))
2375 rsrc_print_resource_directory (FILE * file
,
2377 unsigned int indent
,
2379 rsrc_regions
* regions
,
2382 unsigned int num_names
, num_ids
;
2383 bfd_byte
* highest_data
= data
;
2385 if (data
+ 16 >= regions
->section_end
)
2386 return regions
->section_end
+ 1;
2388 fprintf (file
, "%03x %*.s ", (int)(data
- regions
->section_start
), indent
, " ");
2391 case 0: fprintf (file
, "Type"); break;
2392 case 2: fprintf (file
, "Name"); break;
2393 case 4: fprintf (file
, "Language"); break;
2395 fprintf (file
, _("<unknown directory type: %d>\n"), indent
);
2396 /* FIXME: For now we end the printing here. If in the
2397 future more directory types are added to the RSRC spec
2398 then we will need to change this. */
2399 return regions
->section_end
+ 1;
2402 /* xgettext:c-format */
2403 fprintf (file
, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2404 (int) bfd_get_32 (abfd
, data
),
2405 (long) bfd_get_32 (abfd
, data
+ 4),
2406 (int) bfd_get_16 (abfd
, data
+ 8),
2407 (int) bfd_get_16 (abfd
, data
+ 10),
2408 num_names
= (int) bfd_get_16 (abfd
, data
+ 12),
2409 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14));
2412 while (num_names
--)
2414 bfd_byte
* entry_end
;
2416 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, true,
2417 data
, regions
, rva_bias
);
2419 highest_data
= max (highest_data
, entry_end
);
2420 if (entry_end
>= regions
->section_end
)
2426 bfd_byte
* entry_end
;
2428 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, false,
2429 data
, regions
, rva_bias
);
2431 highest_data
= max (highest_data
, entry_end
);
2432 if (entry_end
>= regions
->section_end
)
2436 return max (highest_data
, data
);
2439 /* Display the contents of a .rsrc section. We do not try to
2440 reproduce the resources, windres does that. Instead we dump
2441 the tables in a human readable format. */
2444 rsrc_print_section (bfd
* abfd
, void * vfile
)
2448 FILE * file
= (FILE *) vfile
;
2449 bfd_size_type datasize
;
2452 rsrc_regions regions
;
2454 pe
= pe_data (abfd
);
2458 section
= bfd_get_section_by_name (abfd
, ".rsrc");
2459 if (section
== NULL
)
2461 if (!(section
->flags
& SEC_HAS_CONTENTS
))
2464 datasize
= section
->size
;
2468 rva_bias
= section
->vma
- pe
->pe_opthdr
.ImageBase
;
2470 if (! bfd_malloc_and_get_section (abfd
, section
, & data
))
2476 regions
.section_start
= data
;
2477 regions
.section_end
= data
+ datasize
;
2478 regions
.strings_start
= NULL
;
2479 regions
.resource_start
= NULL
;
2482 fprintf (file
, "\nThe .rsrc Resource Directory section:\n");
2484 while (data
< regions
.section_end
)
2486 bfd_byte
* p
= data
;
2488 data
= rsrc_print_resource_directory (file
, abfd
, 0, data
, & regions
, rva_bias
);
2490 if (data
== regions
.section_end
+ 1)
2491 fprintf (file
, _("Corrupt .rsrc section detected!\n"));
2494 /* Align data before continuing. */
2495 int align
= (1 << section
->alignment_power
) - 1;
2497 data
= (bfd_byte
*) (((ptrdiff_t) (data
+ align
)) & ~ align
);
2498 rva_bias
+= data
- p
;
2500 /* For reasons that are unclear .rsrc sections are sometimes created
2501 aligned to a 1^3 boundary even when their alignment is set at
2502 1^2. Catch that case here before we issue a spurious warning
2504 if (data
== (regions
.section_end
- 4))
2505 data
= regions
.section_end
;
2506 else if (data
< regions
.section_end
)
2508 /* If the extra data is all zeros then do not complain.
2509 This is just padding so that the section meets the
2510 page size requirements. */
2511 while (++ data
< regions
.section_end
)
2514 if (data
< regions
.section_end
)
2515 fprintf (file
, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2520 if (regions
.strings_start
!= NULL
)
2521 fprintf (file
, _(" String table starts at offset: %#03x\n"),
2522 (int) (regions
.strings_start
- regions
.section_start
));
2523 if (regions
.resource_start
!= NULL
)
2524 fprintf (file
, _(" Resources start at offset: %#03x\n"),
2525 (int) (regions
.resource_start
- regions
.section_start
));
2527 free (regions
.section_start
);
2531 #define IMAGE_NUMBEROF_DEBUG_TYPES 17
2533 static char * debug_type_names
[IMAGE_NUMBEROF_DEBUG_TYPES
] =
2555 pe_print_debugdata (bfd
* abfd
, void * vfile
)
2557 FILE *file
= (FILE *) vfile
;
2558 pe_data_type
*pe
= pe_data (abfd
);
2559 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2562 bfd_size_type dataoff
;
2565 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2566 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2571 addr
+= extra
->ImageBase
;
2572 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2574 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2578 if (section
== NULL
)
2581 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2584 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
2587 _("\nThere is a debug directory in %s, but that section has no contents\n"),
2591 else if (section
->size
< size
)
2594 _("\nError: section %s contains the debug data starting address but it is too small\n"),
2599 fprintf (file
, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2600 section
->name
, (unsigned long) addr
);
2602 dataoff
= addr
- section
->vma
;
2604 if (size
> (section
->size
- dataoff
))
2606 fprintf (file
, _("The debug data size field in the data directory is too big for the section"));
2611 _("Type Size Rva Offset\n"));
2613 /* Read the whole section. */
2614 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2620 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2622 const char *type_name
;
2623 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2624 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2625 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2627 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2629 if ((idd
.Type
) >= IMAGE_NUMBEROF_DEBUG_TYPES
)
2630 type_name
= debug_type_names
[0];
2632 type_name
= debug_type_names
[idd
.Type
];
2634 fprintf (file
, " %2ld %14s %08lx %08lx %08lx\n",
2635 idd
.Type
, type_name
, idd
.SizeOfData
,
2636 idd
.AddressOfRawData
, idd
.PointerToRawData
);
2638 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_CODEVIEW
)
2640 char signature
[CV_INFO_SIGNATURE_LENGTH
* 2 + 1];
2641 /* PR 17512: file: 065-29434-0.001:0.1
2642 We need to use a 32-bit aligned buffer
2643 to safely read in a codeview record. */
2644 char buffer
[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO
);
2647 CODEVIEW_INFO
*cvinfo
= (CODEVIEW_INFO
*) buffer
;
2649 /* The debug entry doesn't have to have to be in a section,
2650 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2651 if (!_bfd_XXi_slurp_codeview_record (abfd
, (file_ptr
) idd
.PointerToRawData
,
2652 idd
.SizeOfData
, cvinfo
, &pdb
))
2655 for (j
= 0; j
< cvinfo
->SignatureLength
; j
++)
2656 sprintf (&signature
[j
*2], "%02x", cvinfo
->Signature
[j
] & 0xff);
2658 /* xgettext:c-format */
2659 fprintf (file
, _("(format %c%c%c%c signature %s age %ld pdb %s)\n"),
2660 buffer
[0], buffer
[1], buffer
[2], buffer
[3],
2661 signature
, cvinfo
->Age
, pdb
[0] ? pdb
: "(none)");
2669 if (size
% sizeof (struct external_IMAGE_DEBUG_DIRECTORY
) != 0)
2671 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2677 pe_is_repro (bfd
* abfd
)
2679 pe_data_type
*pe
= pe_data (abfd
);
2680 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2683 bfd_size_type dataoff
;
2687 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2688 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2693 addr
+= extra
->ImageBase
;
2694 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2696 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2700 if ((section
== NULL
)
2701 || (!(section
->flags
& SEC_HAS_CONTENTS
))
2702 || (section
->size
< size
))
2707 dataoff
= addr
- section
->vma
;
2709 if (size
> (section
->size
- dataoff
))
2714 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2720 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2722 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2723 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2724 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2726 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2728 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_REPRO
)
2740 /* Print out the program headers. */
2743 _bfd_XX_print_private_bfd_data_common (bfd
* abfd
, void * vfile
)
2745 FILE *file
= (FILE *) vfile
;
2747 pe_data_type
*pe
= pe_data (abfd
);
2748 struct internal_extra_pe_aouthdr
*i
= &pe
->pe_opthdr
;
2749 const char *subsystem_name
= NULL
;
2752 /* The MS dumpbin program reportedly ands with 0xff0f before
2753 printing the characteristics field. Not sure why. No reason to
2755 fprintf (file
, _("\nCharacteristics 0x%x\n"), pe
->real_flags
);
2757 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2758 PF (IMAGE_FILE_RELOCS_STRIPPED
, "relocations stripped");
2759 PF (IMAGE_FILE_EXECUTABLE_IMAGE
, "executable");
2760 PF (IMAGE_FILE_LINE_NUMS_STRIPPED
, "line numbers stripped");
2761 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED
, "symbols stripped");
2762 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE
, "large address aware");
2763 PF (IMAGE_FILE_BYTES_REVERSED_LO
, "little endian");
2764 PF (IMAGE_FILE_32BIT_MACHINE
, "32 bit words");
2765 PF (IMAGE_FILE_DEBUG_STRIPPED
, "debugging information removed");
2766 PF (IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP
, "copy to swap file if on removable media");
2767 PF (IMAGE_FILE_NET_RUN_FROM_SWAP
, "copy to swap file if on network media");
2768 PF (IMAGE_FILE_SYSTEM
, "system file");
2769 PF (IMAGE_FILE_DLL
, "DLL");
2770 PF (IMAGE_FILE_UP_SYSTEM_ONLY
, "run only on uniprocessor machine");
2771 PF (IMAGE_FILE_BYTES_REVERSED_HI
, "big endian");
2775 If a PE_IMAGE_DEBUG_TYPE_REPRO entry is present in the debug directory, the
2776 timestamp is to be interpreted as the hash of a reproducible build.
2778 if (pe_is_repro (abfd
))
2780 fprintf (file
, "\nTime/Date\t\t%08lx", pe
->coff
.timestamp
);
2781 fprintf (file
, "\t(This is a reproducible build file hash, not a timestamp)\n");
2785 /* ctime implies '\n'. */
2786 time_t t
= pe
->coff
.timestamp
;
2787 fprintf (file
, "\nTime/Date\t\t%s", ctime (&t
));
2790 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2791 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2793 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2794 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2796 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2797 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2802 case IMAGE_NT_OPTIONAL_HDR_MAGIC
:
2805 case IMAGE_NT_OPTIONAL_HDR64_MAGIC
:
2808 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC
:
2815 fprintf (file
, "Magic\t\t\t%04x", i
->Magic
);
2817 fprintf (file
, "\t(%s)",name
);
2818 fprintf (file
, "\nMajorLinkerVersion\t%d\n", i
->MajorLinkerVersion
);
2819 fprintf (file
, "MinorLinkerVersion\t%d\n", i
->MinorLinkerVersion
);
2820 fprintf (file
, "SizeOfCode\t\t");
2821 bfd_fprintf_vma (abfd
, file
, i
->SizeOfCode
);
2822 fprintf (file
, "\nSizeOfInitializedData\t");
2823 bfd_fprintf_vma (abfd
, file
, i
->SizeOfInitializedData
);
2824 fprintf (file
, "\nSizeOfUninitializedData\t");
2825 bfd_fprintf_vma (abfd
, file
, i
->SizeOfUninitializedData
);
2826 fprintf (file
, "\nAddressOfEntryPoint\t");
2827 bfd_fprintf_vma (abfd
, file
, i
->AddressOfEntryPoint
);
2828 fprintf (file
, "\nBaseOfCode\t\t");
2829 bfd_fprintf_vma (abfd
, file
, i
->BaseOfCode
);
2830 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
2831 /* PE32+ does not have BaseOfData member! */
2832 fprintf (file
, "\nBaseOfData\t\t");
2833 bfd_fprintf_vma (abfd
, file
, i
->BaseOfData
);
2836 fprintf (file
, "\nImageBase\t\t");
2837 bfd_fprintf_vma (abfd
, file
, i
->ImageBase
);
2838 fprintf (file
, "\nSectionAlignment\t%08x\n", i
->SectionAlignment
);
2839 fprintf (file
, "FileAlignment\t\t%08x\n", i
->FileAlignment
);
2840 fprintf (file
, "MajorOSystemVersion\t%d\n", i
->MajorOperatingSystemVersion
);
2841 fprintf (file
, "MinorOSystemVersion\t%d\n", i
->MinorOperatingSystemVersion
);
2842 fprintf (file
, "MajorImageVersion\t%d\n", i
->MajorImageVersion
);
2843 fprintf (file
, "MinorImageVersion\t%d\n", i
->MinorImageVersion
);
2844 fprintf (file
, "MajorSubsystemVersion\t%d\n", i
->MajorSubsystemVersion
);
2845 fprintf (file
, "MinorSubsystemVersion\t%d\n", i
->MinorSubsystemVersion
);
2846 fprintf (file
, "Win32Version\t\t%08x\n", i
->Reserved1
);
2847 fprintf (file
, "SizeOfImage\t\t%08x\n", i
->SizeOfImage
);
2848 fprintf (file
, "SizeOfHeaders\t\t%08x\n", i
->SizeOfHeaders
);
2849 fprintf (file
, "CheckSum\t\t%08x\n", i
->CheckSum
);
2851 switch (i
->Subsystem
)
2853 case IMAGE_SUBSYSTEM_UNKNOWN
:
2854 subsystem_name
= "unspecified";
2856 case IMAGE_SUBSYSTEM_NATIVE
:
2857 subsystem_name
= "NT native";
2859 case IMAGE_SUBSYSTEM_WINDOWS_GUI
:
2860 subsystem_name
= "Windows GUI";
2862 case IMAGE_SUBSYSTEM_WINDOWS_CUI
:
2863 subsystem_name
= "Windows CUI";
2865 case IMAGE_SUBSYSTEM_POSIX_CUI
:
2866 subsystem_name
= "POSIX CUI";
2868 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI
:
2869 subsystem_name
= "Wince CUI";
2871 /* These are from UEFI Platform Initialization Specification 1.1. */
2872 case IMAGE_SUBSYSTEM_EFI_APPLICATION
:
2873 subsystem_name
= "EFI application";
2875 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
:
2876 subsystem_name
= "EFI boot service driver";
2878 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
:
2879 subsystem_name
= "EFI runtime driver";
2881 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER
:
2882 subsystem_name
= "SAL runtime driver";
2884 /* This is from revision 8.0 of the MS PE/COFF spec */
2885 case IMAGE_SUBSYSTEM_XBOX
:
2886 subsystem_name
= "XBOX";
2888 /* Added default case for clarity - subsystem_name is NULL anyway. */
2890 subsystem_name
= NULL
;
2893 fprintf (file
, "Subsystem\t\t%08x", i
->Subsystem
);
2895 fprintf (file
, "\t(%s)", subsystem_name
);
2896 fprintf (file
, "\nDllCharacteristics\t%08x\n", i
->DllCharacteristics
);
2897 if (i
->DllCharacteristics
)
2899 unsigned short dllch
= i
->DllCharacteristics
;
2900 const char *indent
= "\t\t\t\t\t";
2902 if (dllch
& IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA
)
2903 fprintf (file
, "%sHIGH_ENTROPY_VA\n", indent
);
2904 if (dllch
& IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE
)
2905 fprintf (file
, "%sDYNAMIC_BASE\n", indent
);
2906 if (dllch
& IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY
)
2907 fprintf (file
, "%sFORCE_INTEGRITY\n", indent
);
2908 if (dllch
& IMAGE_DLL_CHARACTERISTICS_NX_COMPAT
)
2909 fprintf (file
, "%sNX_COMPAT\n", indent
);
2910 if (dllch
& IMAGE_DLLCHARACTERISTICS_NO_ISOLATION
)
2911 fprintf (file
, "%sNO_ISOLATION\n", indent
);
2912 if (dllch
& IMAGE_DLLCHARACTERISTICS_NO_SEH
)
2913 fprintf (file
, "%sNO_SEH\n", indent
);
2914 if (dllch
& IMAGE_DLLCHARACTERISTICS_NO_BIND
)
2915 fprintf (file
, "%sNO_BIND\n", indent
);
2916 if (dllch
& IMAGE_DLLCHARACTERISTICS_APPCONTAINER
)
2917 fprintf (file
, "%sAPPCONTAINER\n", indent
);
2918 if (dllch
& IMAGE_DLLCHARACTERISTICS_WDM_DRIVER
)
2919 fprintf (file
, "%sWDM_DRIVER\n", indent
);
2920 if (dllch
& IMAGE_DLLCHARACTERISTICS_GUARD_CF
)
2921 fprintf (file
, "%sGUARD_CF\n", indent
);
2922 if (dllch
& IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE
)
2923 fprintf (file
, "%sTERMINAL_SERVICE_AWARE\n", indent
);
2925 fprintf (file
, "SizeOfStackReserve\t");
2926 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackReserve
);
2927 fprintf (file
, "\nSizeOfStackCommit\t");
2928 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackCommit
);
2929 fprintf (file
, "\nSizeOfHeapReserve\t");
2930 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapReserve
);
2931 fprintf (file
, "\nSizeOfHeapCommit\t");
2932 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapCommit
);
2933 fprintf (file
, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i
->LoaderFlags
);
2934 fprintf (file
, "NumberOfRvaAndSizes\t%08lx\n",
2935 (unsigned long) i
->NumberOfRvaAndSizes
);
2937 fprintf (file
, "\nThe Data Directory\n");
2938 for (j
= 0; j
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; j
++)
2940 fprintf (file
, "Entry %1x ", j
);
2941 bfd_fprintf_vma (abfd
, file
, i
->DataDirectory
[j
].VirtualAddress
);
2942 fprintf (file
, " %08lx ", (unsigned long) i
->DataDirectory
[j
].Size
);
2943 fprintf (file
, "%s\n", dir_names
[j
]);
2946 pe_print_idata (abfd
, vfile
);
2947 pe_print_edata (abfd
, vfile
);
2948 if (bfd_coff_have_print_pdata (abfd
))
2949 bfd_coff_print_pdata (abfd
, vfile
);
2951 pe_print_pdata (abfd
, vfile
);
2952 pe_print_reloc (abfd
, vfile
);
2953 pe_print_debugdata (abfd
, file
);
2955 rsrc_print_section (abfd
, vfile
);
2961 is_vma_in_section (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sect
, void *obj
)
2963 bfd_vma addr
= * (bfd_vma
*) obj
;
2964 return (addr
>= sect
->vma
) && (addr
< (sect
->vma
+ sect
->size
));
2968 find_section_by_vma (bfd
*abfd
, bfd_vma addr
)
2970 return bfd_sections_find_if (abfd
, is_vma_in_section
, (void *) & addr
);
2973 /* Copy any private info we understand from the input bfd
2974 to the output bfd. */
2977 _bfd_XX_bfd_copy_private_bfd_data_common (bfd
* ibfd
, bfd
* obfd
)
2979 pe_data_type
*ipe
, *ope
;
2982 /* One day we may try to grok other private data. */
2983 if (ibfd
->xvec
->flavour
!= bfd_target_coff_flavour
2984 || obfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
2987 ipe
= pe_data (ibfd
);
2988 ope
= pe_data (obfd
);
2990 /* pe_opthdr is copied in copy_object. */
2991 ope
->dll
= ipe
->dll
;
2993 /* Don't copy input subsystem if output is different from input. */
2994 if (obfd
->xvec
!= ibfd
->xvec
)
2995 ope
->pe_opthdr
.Subsystem
= IMAGE_SUBSYSTEM_UNKNOWN
;
2997 /* For strip: if we removed .reloc, we'll make a real mess of things
2998 if we don't remove this entry as well. */
2999 if (! pe_data (obfd
)->has_reloc_section
)
3001 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].VirtualAddress
= 0;
3002 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].Size
= 0;
3005 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
3006 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
3008 if (! pe_data (ibfd
)->has_reloc_section
3009 && ! (pe_data (ibfd
)->real_flags
& IMAGE_FILE_RELOCS_STRIPPED
))
3010 pe_data (obfd
)->dont_strip_reloc
= 1;
3012 memcpy (ope
->dos_message
, ipe
->dos_message
, sizeof (ope
->dos_message
));
3014 /* The file offsets contained in the debug directory need rewriting. */
3015 size
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
;
3018 bfd_vma addr
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
3019 + ope
->pe_opthdr
.ImageBase
;
3020 /* In particular a .buildid section may overlap (in VA space) with
3021 whatever section comes ahead of it (largely because of section->size
3022 representing s_size, not virt_size). Therefore don't look for the
3023 section containing the first byte, but for that covering the last
3025 bfd_vma last
= addr
+ size
- 1;
3026 asection
*section
= find_section_by_vma (obfd
, last
);
3028 if (section
!= NULL
)
3031 bfd_vma dataoff
= addr
- section
->vma
;
3033 /* PR 17512: file: 0f15796a. */
3034 if (addr
< section
->vma
3035 || section
->size
< dataoff
3036 || section
->size
- dataoff
< size
)
3038 /* xgettext:c-format */
3040 (_("%pB: Data Directory (%lx bytes at %" PRIx64
") "
3041 "extends across section boundary at %" PRIx64
),
3042 obfd
, ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
,
3043 (uint64_t) addr
, (uint64_t) section
->vma
);
3047 if ((section
->flags
& SEC_HAS_CONTENTS
) != 0
3048 && bfd_malloc_and_get_section (obfd
, section
, &data
))
3051 struct external_IMAGE_DEBUG_DIRECTORY
*dd
=
3052 (struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
);
3054 for (i
= 0; i
< ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
3055 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
3057 asection
*ddsection
;
3058 struct external_IMAGE_DEBUG_DIRECTORY
*edd
= &(dd
[i
]);
3059 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
3062 _bfd_XXi_swap_debugdir_in (obfd
, edd
, &idd
);
3064 /* RVA 0 means only offset is valid, not handled yet. */
3065 if (idd
.AddressOfRawData
== 0)
3068 idd_vma
= idd
.AddressOfRawData
+ ope
->pe_opthdr
.ImageBase
;
3069 ddsection
= find_section_by_vma (obfd
, idd_vma
);
3071 continue; /* Not in a section! */
3073 idd
.PointerToRawData
3074 = ddsection
->filepos
+ idd_vma
- ddsection
->vma
;
3075 _bfd_XXi_swap_debugdir_out (obfd
, &idd
, edd
);
3078 if (!bfd_set_section_contents (obfd
, section
, data
, 0,
3081 _bfd_error_handler (_("failed to update file offsets"
3082 " in debug directory"));
3090 _bfd_error_handler (_("%pB: failed to read "
3091 "debug data section"), obfd
);
3100 /* Copy private section data. */
3103 _bfd_XX_bfd_copy_private_section_data (bfd
*ibfd
,
3108 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
3109 || bfd_get_flavour (obfd
) != bfd_target_coff_flavour
)
3112 if (coff_section_data (ibfd
, isec
) != NULL
3113 && pei_section_data (ibfd
, isec
) != NULL
)
3115 if (coff_section_data (obfd
, osec
) == NULL
)
3117 size_t amt
= sizeof (struct coff_section_tdata
);
3118 osec
->used_by_bfd
= bfd_zalloc (obfd
, amt
);
3119 if (osec
->used_by_bfd
== NULL
)
3123 if (pei_section_data (obfd
, osec
) == NULL
)
3125 size_t amt
= sizeof (struct pei_section_tdata
);
3126 coff_section_data (obfd
, osec
)->tdata
= bfd_zalloc (obfd
, amt
);
3127 if (coff_section_data (obfd
, osec
)->tdata
== NULL
)
3131 pei_section_data (obfd
, osec
)->virt_size
=
3132 pei_section_data (ibfd
, isec
)->virt_size
;
3133 pei_section_data (obfd
, osec
)->pe_flags
=
3134 pei_section_data (ibfd
, isec
)->pe_flags
;
3141 _bfd_XX_get_symbol_info (bfd
* abfd
, asymbol
*symbol
, symbol_info
*ret
)
3143 coff_get_symbol_info (abfd
, symbol
, ret
);
3146 #if !defined(COFF_WITH_pep) && (defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64))
3148 sort_x64_pdata (const void *l
, const void *r
)
3150 const char *lp
= (const char *) l
;
3151 const char *rp
= (const char *) r
;
3153 vl
= bfd_getl32 (lp
); vr
= bfd_getl32 (rp
);
3155 return (vl
< vr
? -1 : 1);
3156 /* We compare just begin address. */
3161 /* Functions to process a .rsrc section. */
3163 static unsigned int sizeof_leaves
;
3164 static unsigned int sizeof_strings
;
3165 static unsigned int sizeof_tables_and_entries
;
3168 rsrc_count_directory (bfd
*, bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
3171 rsrc_count_entries (bfd
*abfd
,
3173 bfd_byte
*datastart
,
3178 unsigned long entry
, addr
, size
;
3180 if (data
+ 8 >= dataend
)
3187 entry
= (long) bfd_get_32 (abfd
, data
);
3189 if (HighBitSet (entry
))
3190 name
= datastart
+ WithoutHighBit (entry
);
3192 name
= datastart
+ entry
- rva_bias
;
3194 if (name
+ 2 >= dataend
|| name
< datastart
)
3197 unsigned int len
= bfd_get_16 (abfd
, name
);
3198 if (len
== 0 || len
> 256)
3202 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
3204 if (HighBitSet (entry
))
3206 data
= datastart
+ WithoutHighBit (entry
);
3208 if (data
<= datastart
|| data
>= dataend
)
3211 return rsrc_count_directory (abfd
, datastart
, data
, dataend
, rva_bias
);
3214 if (datastart
+ entry
+ 16 >= dataend
)
3217 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
);
3218 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4);
3220 return datastart
+ addr
- rva_bias
+ size
;
3224 rsrc_count_directory (bfd
* abfd
,
3225 bfd_byte
* datastart
,
3230 unsigned int num_entries
, num_ids
;
3231 bfd_byte
* highest_data
= data
;
3233 if (data
+ 16 >= dataend
)
3236 num_entries
= (int) bfd_get_16 (abfd
, data
+ 12);
3237 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14);
3239 num_entries
+= num_ids
;
3243 while (num_entries
--)
3245 bfd_byte
* entry_end
;
3247 entry_end
= rsrc_count_entries (abfd
, num_entries
>= num_ids
,
3248 datastart
, data
, dataend
, rva_bias
);
3250 highest_data
= max (highest_data
, entry_end
);
3251 if (entry_end
>= dataend
)
3255 return max (highest_data
, data
);
3258 typedef struct rsrc_dir_chain
3260 unsigned int num_entries
;
3261 struct rsrc_entry
* first_entry
;
3262 struct rsrc_entry
* last_entry
;
3265 typedef struct rsrc_directory
3267 unsigned int characteristics
;
3272 rsrc_dir_chain names
;
3275 struct rsrc_entry
* entry
;
3278 typedef struct rsrc_string
3284 typedef struct rsrc_leaf
3287 unsigned int codepage
;
3291 typedef struct rsrc_entry
3297 struct rsrc_string name
;
3303 struct rsrc_directory
* directory
;
3304 struct rsrc_leaf
* leaf
;
3307 struct rsrc_entry
* next_entry
;
3308 struct rsrc_directory
* parent
;
3312 rsrc_parse_directory (bfd
*, rsrc_directory
*, bfd_byte
*,
3313 bfd_byte
*, bfd_byte
*, bfd_vma
, rsrc_entry
*);
3316 rsrc_parse_entry (bfd
*abfd
,
3319 bfd_byte
*datastart
,
3323 rsrc_directory
*parent
)
3325 unsigned long val
, addr
, size
;
3327 val
= bfd_get_32 (abfd
, data
);
3329 entry
->parent
= parent
;
3330 entry
->is_name
= is_name
;
3336 if (HighBitSet (val
))
3338 val
= WithoutHighBit (val
);
3340 address
= datastart
+ val
;
3344 address
= datastart
+ val
- rva_bias
;
3347 if (address
+ 3 > dataend
)
3350 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, address
);
3351 entry
->name_id
.name
.string
= address
+ 2;
3354 entry
->name_id
.id
= val
;
3356 val
= bfd_get_32 (abfd
, data
+ 4);
3358 if (HighBitSet (val
))
3360 entry
->is_dir
= true;
3361 entry
->value
.directory
= bfd_malloc (sizeof (*entry
->value
.directory
));
3362 if (entry
->value
.directory
== NULL
)
3365 return rsrc_parse_directory (abfd
, entry
->value
.directory
,
3367 datastart
+ WithoutHighBit (val
),
3368 dataend
, rva_bias
, entry
);
3371 entry
->is_dir
= false;
3372 entry
->value
.leaf
= bfd_malloc (sizeof (*entry
->value
.leaf
));
3373 if (entry
->value
.leaf
== NULL
)
3376 data
= datastart
+ val
;
3377 if (data
< datastart
|| data
+ 12 > dataend
)
3380 addr
= bfd_get_32 (abfd
, data
);
3381 size
= entry
->value
.leaf
->size
= bfd_get_32 (abfd
, data
+ 4);
3382 entry
->value
.leaf
->codepage
= bfd_get_32 (abfd
, data
+ 8);
3383 /* FIXME: We assume that the reserved field (data + 12) is OK. */
3385 if (size
> dataend
- datastart
- (addr
- rva_bias
))
3387 entry
->value
.leaf
->data
= bfd_malloc (size
);
3388 if (entry
->value
.leaf
->data
== NULL
)
3391 memcpy (entry
->value
.leaf
->data
, datastart
+ addr
- rva_bias
, size
);
3392 return datastart
+ (addr
- rva_bias
) + size
;
3396 rsrc_parse_entries (bfd
*abfd
,
3397 rsrc_dir_chain
*chain
,
3399 bfd_byte
*highest_data
,
3400 bfd_byte
*datastart
,
3404 rsrc_directory
*parent
)
3409 if (chain
->num_entries
== 0)
3411 chain
->first_entry
= chain
->last_entry
= NULL
;
3412 return highest_data
;
3415 entry
= bfd_malloc (sizeof (*entry
));
3419 chain
->first_entry
= entry
;
3421 for (i
= chain
->num_entries
; i
--;)
3423 bfd_byte
* entry_end
;
3425 entry_end
= rsrc_parse_entry (abfd
, is_name
, entry
, datastart
,
3426 data
, dataend
, rva_bias
, parent
);
3428 highest_data
= max (entry_end
, highest_data
);
3429 if (entry_end
> dataend
)
3434 entry
->next_entry
= bfd_malloc (sizeof (*entry
));
3435 entry
= entry
->next_entry
;
3440 entry
->next_entry
= NULL
;
3443 chain
->last_entry
= entry
;
3445 return highest_data
;
3449 rsrc_parse_directory (bfd
* abfd
,
3450 rsrc_directory
* table
,
3451 bfd_byte
* datastart
,
3457 bfd_byte
* highest_data
= data
;
3462 table
->characteristics
= bfd_get_32 (abfd
, data
);
3463 table
->time
= bfd_get_32 (abfd
, data
+ 4);
3464 table
->major
= bfd_get_16 (abfd
, data
+ 8);
3465 table
->minor
= bfd_get_16 (abfd
, data
+ 10);
3466 table
->names
.num_entries
= bfd_get_16 (abfd
, data
+ 12);
3467 table
->ids
.num_entries
= bfd_get_16 (abfd
, data
+ 14);
3468 table
->entry
= entry
;
3472 highest_data
= rsrc_parse_entries (abfd
, & table
->names
, true, data
,
3473 datastart
, data
, dataend
, rva_bias
, table
);
3474 data
+= table
->names
.num_entries
* 8;
3476 highest_data
= rsrc_parse_entries (abfd
, & table
->ids
, false, highest_data
,
3477 datastart
, data
, dataend
, rva_bias
, table
);
3478 data
+= table
->ids
.num_entries
* 8;
3480 return max (highest_data
, data
);
3483 typedef struct rsrc_write_data
3486 bfd_byte
* datastart
;
3487 bfd_byte
* next_table
;
3488 bfd_byte
* next_leaf
;
3489 bfd_byte
* next_string
;
3490 bfd_byte
* next_data
;
3495 rsrc_write_string (rsrc_write_data
* data
,
3496 rsrc_string
* string
)
3498 bfd_put_16 (data
->abfd
, string
->len
, data
->next_string
);
3499 memcpy (data
->next_string
+ 2, string
->string
, string
->len
* 2);
3500 data
->next_string
+= (string
->len
+ 1) * 2;
3503 static inline unsigned int
3504 rsrc_compute_rva (rsrc_write_data
* data
,
3507 return (addr
- data
->datastart
) + data
->rva_bias
;
3511 rsrc_write_leaf (rsrc_write_data
* data
,
3514 bfd_put_32 (data
->abfd
, rsrc_compute_rva (data
, data
->next_data
),
3516 bfd_put_32 (data
->abfd
, leaf
->size
, data
->next_leaf
+ 4);
3517 bfd_put_32 (data
->abfd
, leaf
->codepage
, data
->next_leaf
+ 8);
3518 bfd_put_32 (data
->abfd
, 0 /*reserved*/, data
->next_leaf
+ 12);
3519 data
->next_leaf
+= 16;
3521 memcpy (data
->next_data
, leaf
->data
, leaf
->size
);
3522 /* An undocumented feature of Windows resources is that each unit
3523 of raw data is 8-byte aligned... */
3524 data
->next_data
+= ((leaf
->size
+ 7) & ~7);
3527 static void rsrc_write_directory (rsrc_write_data
*, rsrc_directory
*);
3530 rsrc_write_entry (rsrc_write_data
* data
,
3536 bfd_put_32 (data
->abfd
,
3537 SetHighBit (data
->next_string
- data
->datastart
),
3539 rsrc_write_string (data
, & entry
->name_id
.name
);
3542 bfd_put_32 (data
->abfd
, entry
->name_id
.id
, where
);
3546 bfd_put_32 (data
->abfd
,
3547 SetHighBit (data
->next_table
- data
->datastart
),
3549 rsrc_write_directory (data
, entry
->value
.directory
);
3553 bfd_put_32 (data
->abfd
, data
->next_leaf
- data
->datastart
, where
+ 4);
3554 rsrc_write_leaf (data
, entry
->value
.leaf
);
3559 rsrc_compute_region_sizes (rsrc_directory
* dir
)
3561 struct rsrc_entry
* entry
;
3566 sizeof_tables_and_entries
+= 16;
3568 for (entry
= dir
->names
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3570 sizeof_tables_and_entries
+= 8;
3572 sizeof_strings
+= (entry
->name_id
.name
.len
+ 1) * 2;
3575 rsrc_compute_region_sizes (entry
->value
.directory
);
3577 sizeof_leaves
+= 16;
3580 for (entry
= dir
->ids
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3582 sizeof_tables_and_entries
+= 8;
3585 rsrc_compute_region_sizes (entry
->value
.directory
);
3587 sizeof_leaves
+= 16;
3592 rsrc_write_directory (rsrc_write_data
* data
,
3593 rsrc_directory
* dir
)
3597 bfd_byte
* next_entry
;
3600 bfd_put_32 (data
->abfd
, dir
->characteristics
, data
->next_table
);
3601 bfd_put_32 (data
->abfd
, 0 /*dir->time*/, data
->next_table
+ 4);
3602 bfd_put_16 (data
->abfd
, dir
->major
, data
->next_table
+ 8);
3603 bfd_put_16 (data
->abfd
, dir
->minor
, data
->next_table
+ 10);
3604 bfd_put_16 (data
->abfd
, dir
->names
.num_entries
, data
->next_table
+ 12);
3605 bfd_put_16 (data
->abfd
, dir
->ids
.num_entries
, data
->next_table
+ 14);
3607 /* Compute where the entries and the next table will be placed. */
3608 next_entry
= data
->next_table
+ 16;
3609 data
->next_table
= next_entry
+ (dir
->names
.num_entries
* 8)
3610 + (dir
->ids
.num_entries
* 8);
3611 nt
= data
->next_table
;
3613 /* Write the entries. */
3614 for (i
= dir
->names
.num_entries
, entry
= dir
->names
.first_entry
;
3615 i
> 0 && entry
!= NULL
;
3616 i
--, entry
= entry
->next_entry
)
3618 BFD_ASSERT (entry
->is_name
);
3619 rsrc_write_entry (data
, next_entry
, entry
);
3622 BFD_ASSERT (i
== 0);
3623 BFD_ASSERT (entry
== NULL
);
3625 for (i
= dir
->ids
.num_entries
, entry
= dir
->ids
.first_entry
;
3626 i
> 0 && entry
!= NULL
;
3627 i
--, entry
= entry
->next_entry
)
3629 BFD_ASSERT (! entry
->is_name
);
3630 rsrc_write_entry (data
, next_entry
, entry
);
3633 BFD_ASSERT (i
== 0);
3634 BFD_ASSERT (entry
== NULL
);
3635 BFD_ASSERT (nt
== next_entry
);
3638 #if ! defined __CYGWIN__ && ! defined __MINGW32__
3639 /* Return the length (number of units) of the first character in S,
3640 putting its 'ucs4_t' representation in *PUC. */
3643 u16_mbtouc (wint_t * puc
, const unsigned short * s
, unsigned int n
)
3645 unsigned short c
= * s
;
3647 if (c
< 0xd800 || c
>= 0xe000)
3657 if (s
[1] >= 0xdc00 && s
[1] < 0xe000)
3659 *puc
= 0x10000 + ((c
- 0xd800) << 10) + (s
[1] - 0xdc00);
3665 /* Incomplete multibyte character. */
3671 /* Invalid multibyte character. */
3675 #endif /* not Cygwin/Mingw */
3677 /* Perform a comparison of two entries. */
3679 rsrc_cmp (bool is_name
, rsrc_entry
* a
, rsrc_entry
* b
)
3688 return a
->name_id
.id
- b
->name_id
.id
;
3690 /* We have to perform a case insenstive, unicode string comparison... */
3691 astring
= a
->name_id
.name
.string
;
3692 alen
= a
->name_id
.name
.len
;
3693 bstring
= b
->name_id
.name
.string
;
3694 blen
= b
->name_id
.name
.len
;
3696 #if defined __CYGWIN__ || defined __MINGW32__
3697 /* Under Windows hosts (both Cygwin and Mingw types),
3698 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3699 function however goes by different names in the two environments... */
3703 #define rscpcmp wcsncasecmp
3706 #define rscpcmp wcsnicmp
3709 res
= rscpcmp ((const wchar_t *) astring
, (const wchar_t *) bstring
,
3717 for (i
= min (alen
, blen
); i
--; astring
+= 2, bstring
+= 2)
3722 /* Convert UTF-16 unicode characters into wchar_t characters
3723 so that we can then perform a case insensitive comparison. */
3724 unsigned int Alen
= u16_mbtouc (& awc
, (const unsigned short *) astring
, 2);
3725 unsigned int Blen
= u16_mbtouc (& bwc
, (const unsigned short *) bstring
, 2);
3730 awc
= towlower (awc
);
3731 bwc
= towlower (bwc
);
3747 rsrc_print_name (char * buffer
, rsrc_string string
)
3750 bfd_byte
* name
= string
.string
;
3752 for (i
= string
.len
; i
--; name
+= 2)
3753 sprintf (buffer
+ strlen (buffer
), "%.1s", name
);
3757 rsrc_resource_name (rsrc_entry
*entry
, rsrc_directory
*dir
, char *buffer
)
3759 bool is_string
= false;
3763 if (dir
!= NULL
&& dir
->entry
!= NULL
&& dir
->entry
->parent
!= NULL
3764 && dir
->entry
->parent
->entry
!= NULL
)
3766 strcpy (buffer
, "type: ");
3767 if (dir
->entry
->parent
->entry
->is_name
)
3768 rsrc_print_name (buffer
+ strlen (buffer
),
3769 dir
->entry
->parent
->entry
->name_id
.name
);
3772 unsigned int id
= dir
->entry
->parent
->entry
->name_id
.id
;
3774 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3777 case 1: strcat (buffer
, " (CURSOR)"); break;
3778 case 2: strcat (buffer
, " (BITMAP)"); break;
3779 case 3: strcat (buffer
, " (ICON)"); break;
3780 case 4: strcat (buffer
, " (MENU)"); break;
3781 case 5: strcat (buffer
, " (DIALOG)"); break;
3782 case 6: strcat (buffer
, " (STRING)"); is_string
= true; break;
3783 case 7: strcat (buffer
, " (FONTDIR)"); break;
3784 case 8: strcat (buffer
, " (FONT)"); break;
3785 case 9: strcat (buffer
, " (ACCELERATOR)"); break;
3786 case 10: strcat (buffer
, " (RCDATA)"); break;
3787 case 11: strcat (buffer
, " (MESSAGETABLE)"); break;
3788 case 12: strcat (buffer
, " (GROUP_CURSOR)"); break;
3789 case 14: strcat (buffer
, " (GROUP_ICON)"); break;
3790 case 16: strcat (buffer
, " (VERSION)"); break;
3791 case 17: strcat (buffer
, " (DLGINCLUDE)"); break;
3792 case 19: strcat (buffer
, " (PLUGPLAY)"); break;
3793 case 20: strcat (buffer
, " (VXD)"); break;
3794 case 21: strcat (buffer
, " (ANICURSOR)"); break;
3795 case 22: strcat (buffer
, " (ANIICON)"); break;
3796 case 23: strcat (buffer
, " (HTML)"); break;
3797 case 24: strcat (buffer
, " (MANIFEST)"); break;
3798 case 240: strcat (buffer
, " (DLGINIT)"); break;
3799 case 241: strcat (buffer
, " (TOOLBAR)"); break;
3804 if (dir
!= NULL
&& dir
->entry
!= NULL
)
3806 strcat (buffer
, " name: ");
3807 if (dir
->entry
->is_name
)
3808 rsrc_print_name (buffer
+ strlen (buffer
), dir
->entry
->name_id
.name
);
3811 unsigned int id
= dir
->entry
->name_id
.id
;
3813 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3816 sprintf (buffer
+ strlen (buffer
), " (resource id range: %d - %d)",
3817 (id
- 1) << 4, (id
<< 4) - 1);
3823 strcat (buffer
, " lang: ");
3826 rsrc_print_name (buffer
+ strlen (buffer
), entry
->name_id
.name
);
3828 sprintf (buffer
+ strlen (buffer
), "%x", entry
->name_id
.id
);
3834 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3835 their ID is stored in the NAME entry. The bottom four bits are used as
3836 an index into unicode string table that makes up the data of the leaf.
3837 So identical type-name-lang string resources may not actually be
3840 This function is called when we have detected two string resources with
3841 match top-28-bit IDs. We have to scan the string tables inside the leaves
3842 and discover if there are any real collisions. If there are then we report
3843 them and return FALSE. Otherwise we copy any strings from B into A and
3844 then return TRUE. */
3847 rsrc_merge_string_entries (rsrc_entry
* a ATTRIBUTE_UNUSED
,
3848 rsrc_entry
* b ATTRIBUTE_UNUSED
)
3850 unsigned int copy_needed
= 0;
3854 bfd_byte
* new_data
;
3857 /* Step one: Find out what we have to do. */
3858 BFD_ASSERT (! a
->is_dir
);
3859 astring
= a
->value
.leaf
->data
;
3861 BFD_ASSERT (! b
->is_dir
);
3862 bstring
= b
->value
.leaf
->data
;
3864 for (i
= 0; i
< 16; i
++)
3866 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3867 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3871 copy_needed
+= blen
* 2;
3875 else if (alen
!= blen
)
3876 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3878 /* alen == blen != 0. We might have two identical strings. If so we
3879 can ignore the second one. There is no need for wchar_t vs UTF-16
3880 theatrics here - we are only interested in (case sensitive) equality. */
3881 else if (memcmp (astring
+ 2, bstring
+ 2, alen
* 2) != 0)
3884 astring
+= (alen
+ 1) * 2;
3885 bstring
+= (blen
+ 1) * 2;
3890 if (a
->parent
!= NULL
3891 && a
->parent
->entry
!= NULL
3892 && !a
->parent
->entry
->is_name
)
3893 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3894 ((a
->parent
->entry
->name_id
.id
- 1) << 4) + i
);
3898 if (copy_needed
== 0)
3901 /* If we reach here then A and B must both have non-colliding strings.
3902 (We never get string resources with fully empty string tables).
3903 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3905 new_data
= bfd_malloc (a
->value
.leaf
->size
+ copy_needed
);
3906 if (new_data
== NULL
)
3910 astring
= a
->value
.leaf
->data
;
3911 bstring
= b
->value
.leaf
->data
;
3913 for (i
= 0; i
< 16; i
++)
3915 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3916 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3920 memcpy (nstring
, astring
, (alen
+ 1) * 2);
3921 nstring
+= (alen
+ 1) * 2;
3925 memcpy (nstring
, bstring
, (blen
+ 1) * 2);
3926 nstring
+= (blen
+ 1) * 2;
3934 astring
+= (alen
+ 1) * 2;
3935 bstring
+= (blen
+ 1) * 2;
3938 BFD_ASSERT (nstring
- new_data
== (signed) (a
->value
.leaf
->size
+ copy_needed
));
3940 free (a
->value
.leaf
->data
);
3941 a
->value
.leaf
->data
= new_data
;
3942 a
->value
.leaf
->size
+= copy_needed
;
3947 static void rsrc_merge (rsrc_entry
*, rsrc_entry
*);
3949 /* Sort the entries in given part of the directory.
3950 We use an old fashioned bubble sort because we are dealing
3951 with lists and we want to handle matches specially. */
3954 rsrc_sort_entries (rsrc_dir_chain
*chain
,
3956 rsrc_directory
*dir
)
3960 rsrc_entry
** points_to_entry
;
3963 if (chain
->num_entries
< 2)
3969 points_to_entry
= & chain
->first_entry
;
3970 entry
= * points_to_entry
;
3971 next
= entry
->next_entry
;
3975 signed int cmp
= rsrc_cmp (is_name
, entry
, next
);
3979 entry
->next_entry
= next
->next_entry
;
3980 next
->next_entry
= entry
;
3981 * points_to_entry
= next
;
3982 points_to_entry
= & next
->next_entry
;
3983 next
= entry
->next_entry
;
3988 if (entry
->is_dir
&& next
->is_dir
)
3990 /* When we encounter identical directory entries we have to
3991 merge them together. The exception to this rule is for
3992 resource manifests - there can only be one of these,
3993 even if they differ in language. Zero-language manifests
3994 are assumed to be default manifests (provided by the
3995 Cygwin/MinGW build system) and these can be silently dropped,
3996 unless that would reduce the number of manifests to zero.
3997 There should only ever be one non-zero lang manifest -
3998 if there are more it is an error. A non-zero lang
3999 manifest takes precedence over a default manifest. */
4001 && entry
->name_id
.id
== 1
4003 && dir
->entry
!= NULL
4004 && !dir
->entry
->is_name
4005 && dir
->entry
->name_id
.id
== 0x18)
4007 if (next
->value
.directory
->names
.num_entries
== 0
4008 && next
->value
.directory
->ids
.num_entries
== 1
4009 && !next
->value
.directory
->ids
.first_entry
->is_name
4010 && next
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
4011 /* Fall through so that NEXT is dropped. */
4013 else if (entry
->value
.directory
->names
.num_entries
== 0
4014 && entry
->value
.directory
->ids
.num_entries
== 1
4015 && !entry
->value
.directory
->ids
.first_entry
->is_name
4016 && entry
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
4018 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
4019 entry
->next_entry
= next
->next_entry
;
4020 next
->next_entry
= entry
;
4021 * points_to_entry
= next
;
4022 points_to_entry
= & next
->next_entry
;
4023 next
= entry
->next_entry
;
4028 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
4029 bfd_set_error (bfd_error_file_truncated
);
4033 /* Unhook NEXT from the chain. */
4034 /* FIXME: memory loss here. */
4035 entry
->next_entry
= next
->next_entry
;
4036 chain
->num_entries
--;
4037 if (chain
->num_entries
< 2)
4039 next
= next
->next_entry
;
4042 rsrc_merge (entry
, next
);
4044 else if (entry
->is_dir
!= next
->is_dir
)
4046 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
4047 bfd_set_error (bfd_error_file_truncated
);
4052 /* Otherwise with identical leaves we issue an error
4053 message - because there should never be duplicates.
4054 The exception is Type 18/Name 1/Lang 0 which is the
4055 defaul manifest - this can just be dropped. */
4057 && entry
->name_id
.id
== 0
4059 && dir
->entry
!= NULL
4060 && !dir
->entry
->is_name
4061 && dir
->entry
->name_id
.id
== 1
4062 && dir
->entry
->parent
!= NULL
4063 && dir
->entry
->parent
->entry
!= NULL
4064 && !dir
->entry
->parent
->entry
->is_name
4065 && dir
->entry
->parent
->entry
->name_id
.id
== 0x18 /* RT_MANIFEST */)
4067 else if (dir
!= NULL
4068 && dir
->entry
!= NULL
4069 && dir
->entry
->parent
!= NULL
4070 && dir
->entry
->parent
->entry
!= NULL
4071 && !dir
->entry
->parent
->entry
->is_name
4072 && dir
->entry
->parent
->entry
->name_id
.id
== 0x6 /* RT_STRING */)
4074 /* Strings need special handling. */
4075 if (! rsrc_merge_string_entries (entry
, next
))
4077 /* _bfd_error_handler should have been called inside merge_strings. */
4078 bfd_set_error (bfd_error_file_truncated
);
4085 || dir
->entry
== NULL
4086 || dir
->entry
->parent
== NULL
4087 || dir
->entry
->parent
->entry
== NULL
)
4088 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
4093 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
4094 rsrc_resource_name (entry
, dir
, buff
));
4096 bfd_set_error (bfd_error_file_truncated
);
4101 /* Unhook NEXT from the chain. */
4102 entry
->next_entry
= next
->next_entry
;
4103 chain
->num_entries
--;
4104 if (chain
->num_entries
< 2)
4106 next
= next
->next_entry
;
4110 points_to_entry
= & entry
->next_entry
;
4112 next
= next
->next_entry
;
4117 chain
->last_entry
= entry
;
4122 /* Attach B's chain onto A. */
4124 rsrc_attach_chain (rsrc_dir_chain
* achain
, rsrc_dir_chain
* bchain
)
4126 if (bchain
->num_entries
== 0)
4129 achain
->num_entries
+= bchain
->num_entries
;
4131 if (achain
->first_entry
== NULL
)
4133 achain
->first_entry
= bchain
->first_entry
;
4134 achain
->last_entry
= bchain
->last_entry
;
4138 achain
->last_entry
->next_entry
= bchain
->first_entry
;
4139 achain
->last_entry
= bchain
->last_entry
;
4142 bchain
->num_entries
= 0;
4143 bchain
->first_entry
= bchain
->last_entry
= NULL
;
4147 rsrc_merge (struct rsrc_entry
* a
, struct rsrc_entry
* b
)
4149 rsrc_directory
* adir
;
4150 rsrc_directory
* bdir
;
4152 BFD_ASSERT (a
->is_dir
);
4153 BFD_ASSERT (b
->is_dir
);
4155 adir
= a
->value
.directory
;
4156 bdir
= b
->value
.directory
;
4158 if (adir
->characteristics
!= bdir
->characteristics
)
4160 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics"));
4161 bfd_set_error (bfd_error_file_truncated
);
4165 if (adir
->major
!= bdir
->major
|| adir
->minor
!= bdir
->minor
)
4167 _bfd_error_handler (_(".rsrc merge failure: differing directory versions"));
4168 bfd_set_error (bfd_error_file_truncated
);
4172 /* Attach B's name chain to A. */
4173 rsrc_attach_chain (& adir
->names
, & bdir
->names
);
4175 /* Attach B's ID chain to A. */
4176 rsrc_attach_chain (& adir
->ids
, & bdir
->ids
);
4178 /* Now sort A's entries. */
4179 rsrc_sort_entries (& adir
->names
, true, adir
);
4180 rsrc_sort_entries (& adir
->ids
, false, adir
);
4183 /* Check the .rsrc section. If it contains multiple concatenated
4184 resources then we must merge them properly. Otherwise Windows
4185 will ignore all but the first set. */
4188 rsrc_process_section (bfd
* abfd
,
4189 struct coff_final_link_info
* pfinfo
)
4191 rsrc_directory new_table
;
4197 bfd_byte
* datastart
;
4199 bfd_byte
* new_data
;
4200 unsigned int num_resource_sets
;
4201 rsrc_directory
* type_tables
;
4202 rsrc_write_data write_data
;
4205 unsigned int num_input_rsrc
= 0;
4206 unsigned int max_num_input_rsrc
= 4;
4207 ptrdiff_t * rsrc_sizes
= NULL
;
4209 new_table
.names
.num_entries
= 0;
4210 new_table
.ids
.num_entries
= 0;
4212 sec
= bfd_get_section_by_name (abfd
, ".rsrc");
4213 if (sec
== NULL
|| (size
= sec
->rawsize
) == 0)
4216 pe
= pe_data (abfd
);
4220 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4222 if (! bfd_malloc_and_get_section (abfd
, sec
, &datastart
))
4225 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4226 their lengths. Note - we rely upon the fact that the linker script
4227 does *not* sort the input .rsrc sections, so that the order in the
4228 linkinfo list matches the order in the output .rsrc section.
4230 We need to know the lengths because each input .rsrc section has padding
4231 at the end of a variable amount. (It does not appear to be based upon
4232 the section alignment or the file alignment). We need to skip any
4233 padding bytes when parsing the input .rsrc sections. */
4235 rsrc_sizes
= bfd_malloc (max_num_input_rsrc
* sizeof (*rsrc_sizes
));
4236 if (rsrc_sizes
== NULL
)
4239 for (input
= pfinfo
->info
->input_bfds
;
4241 input
= input
->link
.next
)
4243 asection
* rsrc_sec
= bfd_get_section_by_name (input
, ".rsrc");
4245 /* PR 18372 - skip discarded .rsrc sections. */
4246 if (rsrc_sec
!= NULL
&& !discarded_section (rsrc_sec
))
4248 if (num_input_rsrc
== max_num_input_rsrc
)
4250 max_num_input_rsrc
+= 10;
4251 rsrc_sizes
= bfd_realloc (rsrc_sizes
, max_num_input_rsrc
4252 * sizeof (*rsrc_sizes
));
4253 if (rsrc_sizes
== NULL
)
4257 BFD_ASSERT (rsrc_sec
->size
> 0);
4258 rsrc_sizes
[num_input_rsrc
++] = rsrc_sec
->size
;
4262 if (num_input_rsrc
< 2)
4265 /* Step one: Walk the section, computing the size of the tables,
4266 leaves and data and decide if we need to do anything. */
4267 dataend
= data
+ size
;
4268 num_resource_sets
= 0;
4270 while (data
< dataend
)
4272 bfd_byte
* p
= data
;
4274 data
= rsrc_count_directory (abfd
, data
, data
, dataend
, rva_bias
);
4278 /* Corrupted .rsrc section - cannot merge. */
4279 _bfd_error_handler (_("%pB: .rsrc merge failure: corrupt .rsrc section"),
4281 bfd_set_error (bfd_error_file_truncated
);
4285 if ((data
- p
) > rsrc_sizes
[num_resource_sets
])
4287 _bfd_error_handler (_("%pB: .rsrc merge failure: unexpected .rsrc size"),
4289 bfd_set_error (bfd_error_file_truncated
);
4292 /* FIXME: Should we add a check for "data - p" being much smaller
4293 than rsrc_sizes[num_resource_sets] ? */
4295 data
= p
+ rsrc_sizes
[num_resource_sets
];
4296 rva_bias
+= data
- p
;
4297 ++ num_resource_sets
;
4299 BFD_ASSERT (num_resource_sets
== num_input_rsrc
);
4301 /* Step two: Walk the data again, building trees of the resources. */
4303 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4305 type_tables
= bfd_malloc (num_resource_sets
* sizeof (*type_tables
));
4306 if (type_tables
== NULL
)
4310 while (data
< dataend
)
4312 bfd_byte
* p
= data
;
4314 (void) rsrc_parse_directory (abfd
, type_tables
+ indx
, data
, data
,
4315 dataend
, rva_bias
, NULL
);
4316 data
= p
+ rsrc_sizes
[indx
];
4317 rva_bias
+= data
- p
;
4320 BFD_ASSERT (indx
== num_resource_sets
);
4322 /* Step three: Merge the top level tables (there can be only one).
4324 We must ensure that the merged entries are in ascending order.
4326 We also thread the top level table entries from the old tree onto
4327 the new table, so that they can be pulled off later. */
4329 /* FIXME: Should we verify that all type tables are the same ? */
4330 new_table
.characteristics
= type_tables
[0].characteristics
;
4331 new_table
.time
= type_tables
[0].time
;
4332 new_table
.major
= type_tables
[0].major
;
4333 new_table
.minor
= type_tables
[0].minor
;
4335 /* Chain the NAME entries onto the table. */
4336 new_table
.names
.first_entry
= NULL
;
4337 new_table
.names
.last_entry
= NULL
;
4339 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4340 rsrc_attach_chain (& new_table
.names
, & type_tables
[indx
].names
);
4342 rsrc_sort_entries (& new_table
.names
, true, & new_table
);
4344 /* Chain the ID entries onto the table. */
4345 new_table
.ids
.first_entry
= NULL
;
4346 new_table
.ids
.last_entry
= NULL
;
4348 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4349 rsrc_attach_chain (& new_table
.ids
, & type_tables
[indx
].ids
);
4351 rsrc_sort_entries (& new_table
.ids
, false, & new_table
);
4353 /* Step four: Create new contents for the .rsrc section. */
4354 /* Step four point one: Compute the size of each region of the .rsrc section.
4355 We do this now, rather than earlier, as the merging above may have dropped
4357 sizeof_leaves
= sizeof_strings
= sizeof_tables_and_entries
= 0;
4358 rsrc_compute_region_sizes (& new_table
);
4359 /* We increment sizeof_strings to make sure that resource data
4360 starts on an 8-byte boundary. FIXME: Is this correct ? */
4361 sizeof_strings
= (sizeof_strings
+ 7) & ~ 7;
4363 new_data
= bfd_zalloc (abfd
, size
);
4364 if (new_data
== NULL
)
4367 write_data
.abfd
= abfd
;
4368 write_data
.datastart
= new_data
;
4369 write_data
.next_table
= new_data
;
4370 write_data
.next_leaf
= new_data
+ sizeof_tables_and_entries
;
4371 write_data
.next_string
= write_data
.next_leaf
+ sizeof_leaves
;
4372 write_data
.next_data
= write_data
.next_string
+ sizeof_strings
;
4373 write_data
.rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4375 rsrc_write_directory (& write_data
, & new_table
);
4377 /* Step five: Replace the old contents with the new.
4378 We don't recompute the size as it's too late here to shrink section.
4379 See PR ld/20193 for more details. */
4380 bfd_set_section_contents (pfinfo
->output_bfd
, sec
, new_data
, 0, size
);
4381 sec
->size
= sec
->rawsize
= size
;
4384 /* Step six: Free all the memory that we have used. */
4385 /* FIXME: Free the resource tree, if we have one. */
4390 /* Handle the .idata section and other things that need symbol table
4394 _bfd_XXi_final_link_postscript (bfd
* abfd
, struct coff_final_link_info
*pfinfo
)
4396 struct coff_link_hash_entry
*h1
;
4397 struct bfd_link_info
*info
= pfinfo
->info
;
4400 /* There are a few fields that need to be filled in now while we
4401 have symbol table access.
4403 The .idata subsections aren't directly available as sections, but
4404 they are in the symbol table, so get them from there. */
4406 /* The import directory. This is the address of .idata$2, with size
4407 of .idata$2 + .idata$3. */
4408 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4409 ".idata$2", false, false, true);
4412 /* PR ld/2729: We cannot rely upon all the output sections having been
4413 created properly, so check before referencing them. Issue a warning
4414 message for any sections tht could not be found. */
4415 if ((h1
->root
.type
== bfd_link_hash_defined
4416 || h1
->root
.type
== bfd_link_hash_defweak
)
4417 && h1
->root
.u
.def
.section
!= NULL
4418 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4419 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
=
4420 (h1
->root
.u
.def
.value
4421 + h1
->root
.u
.def
.section
->output_section
->vma
4422 + h1
->root
.u
.def
.section
->output_offset
);
4426 (_("%pB: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4431 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4432 ".idata$4", 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_TABLE
].Size
=
4439 ((h1
->root
.u
.def
.value
4440 + h1
->root
.u
.def
.section
->output_section
->vma
4441 + h1
->root
.u
.def
.section
->output_offset
)
4442 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
);
4446 (_("%pB: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4451 /* The import address table. This is the size/address of
4453 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4454 ".idata$5", false, false, true);
4456 && (h1
->root
.type
== bfd_link_hash_defined
4457 || h1
->root
.type
== bfd_link_hash_defweak
)
4458 && h1
->root
.u
.def
.section
!= NULL
4459 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4460 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4461 (h1
->root
.u
.def
.value
4462 + h1
->root
.u
.def
.section
->output_section
->vma
4463 + h1
->root
.u
.def
.section
->output_offset
);
4467 (_("%pB: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4472 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4473 ".idata$6", 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
)
4479 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4480 ((h1
->root
.u
.def
.value
4481 + h1
->root
.u
.def
.section
->output_section
->vma
4482 + h1
->root
.u
.def
.section
->output_offset
)
4483 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
);
4487 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4494 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4495 "__IAT_start__", false, false, true);
4497 && (h1
->root
.type
== bfd_link_hash_defined
4498 || h1
->root
.type
== bfd_link_hash_defweak
)
4499 && h1
->root
.u
.def
.section
!= NULL
4500 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4505 (h1
->root
.u
.def
.value
4506 + h1
->root
.u
.def
.section
->output_section
->vma
4507 + h1
->root
.u
.def
.section
->output_offset
);
4509 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4510 "__IAT_end__", false, false, true);
4512 && (h1
->root
.type
== bfd_link_hash_defined
4513 || h1
->root
.type
== bfd_link_hash_defweak
)
4514 && h1
->root
.u
.def
.section
!= NULL
4515 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4517 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4518 ((h1
->root
.u
.def
.value
4519 + h1
->root
.u
.def
.section
->output_section
->vma
4520 + h1
->root
.u
.def
.section
->output_offset
)
4522 if (pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
!= 0)
4523 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4524 iat_va
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
4529 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4530 " because .idata$6 is missing"), abfd
);
4536 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4537 (bfd_get_symbol_leading_char (abfd
) != 0
4538 ? "__tls_used" : "_tls_used"),
4539 false, false, true);
4542 if ((h1
->root
.type
== bfd_link_hash_defined
4543 || h1
->root
.type
== bfd_link_hash_defweak
)
4544 && h1
->root
.u
.def
.section
!= NULL
4545 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4546 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].VirtualAddress
=
4547 (h1
->root
.u
.def
.value
4548 + h1
->root
.u
.def
.section
->output_section
->vma
4549 + h1
->root
.u
.def
.section
->output_offset
4550 - pe_data (abfd
)->pe_opthdr
.ImageBase
);
4554 (_("%pB: unable to fill in DataDictionary[9] because __tls_used is missing"),
4558 /* According to PECOFF sepcifications by Microsoft version 8.2
4559 the TLS data directory consists of 4 pointers, followed
4560 by two 4-byte integer. This implies that the total size
4561 is different for 32-bit and 64-bit executables. */
4562 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
4563 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x18;
4565 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x28;
4569 /* If there is a .pdata section and we have linked pdata finally, we
4570 need to sort the entries ascending. */
4571 #if !defined(COFF_WITH_pep) && (defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64))
4573 asection
*sec
= bfd_get_section_by_name (abfd
, ".pdata");
4577 bfd_size_type x
= sec
->rawsize
;
4580 if (bfd_malloc_and_get_section (abfd
, sec
, &tmp_data
))
4584 12, sort_x64_pdata
);
4585 bfd_set_section_contents (pfinfo
->output_bfd
, sec
,
4595 rsrc_process_section (abfd
, pfinfo
);
4597 /* If we couldn't find idata$2, we either have an excessively
4598 trivial program or are in DEEP trouble; we have to assume trivial