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 memcpy (filehdr_out
->dos_message
, filehdr_in
->pe
.dos_message
,
894 sizeof (filehdr_out
->dos_message
));
896 /* Also put in the NT signature. */
897 H_PUT_32 (abfd
, filehdr_in
->pe
.nt_signature
, filehdr_out
->nt_signature
);
903 _bfd_XX_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
905 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
906 FILHDR
*filehdr_out
= (FILHDR
*) out
;
908 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
909 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
910 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->f_timdat
);
911 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
, filehdr_out
->f_symptr
);
912 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
913 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
914 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
920 _bfd_XXi_swap_scnhdr_out (bfd
* abfd
, void * in
, void * out
)
922 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*) in
;
923 SCNHDR
*scnhdr_ext
= (SCNHDR
*) out
;
924 unsigned int ret
= SCNHSZ
;
928 memcpy (scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof (scnhdr_int
->s_name
));
930 ss
= scnhdr_int
->s_vaddr
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
931 if (scnhdr_int
->s_vaddr
< pe_data (abfd
)->pe_opthdr
.ImageBase
)
932 _bfd_error_handler (_("%pB:%.8s: section below image base"),
933 abfd
, scnhdr_int
->s_name
);
934 /* Do not compare lower 32-bits for 64-bit vma. */
935 #if !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
936 else if(ss
!= (ss
& 0xffffffff))
937 _bfd_error_handler (_("%pB:%.8s: RVA truncated"), abfd
, scnhdr_int
->s_name
);
938 PUT_SCNHDR_VADDR (abfd
, ss
& 0xffffffff, scnhdr_ext
->s_vaddr
);
940 PUT_SCNHDR_VADDR (abfd
, ss
, scnhdr_ext
->s_vaddr
);
943 /* NT wants the size data to be rounded up to the next
944 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
946 if ((scnhdr_int
->s_flags
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
) != 0)
948 if (bfd_pei_p (abfd
))
950 ps
= scnhdr_int
->s_size
;
956 ss
= scnhdr_int
->s_size
;
961 if (bfd_pei_p (abfd
))
962 ps
= scnhdr_int
->s_paddr
;
966 ss
= scnhdr_int
->s_size
;
969 PUT_SCNHDR_SIZE (abfd
, ss
,
972 /* s_paddr in PE is really the virtual size. */
973 PUT_SCNHDR_PADDR (abfd
, ps
, scnhdr_ext
->s_paddr
);
975 PUT_SCNHDR_SCNPTR (abfd
, scnhdr_int
->s_scnptr
,
976 scnhdr_ext
->s_scnptr
);
977 PUT_SCNHDR_RELPTR (abfd
, scnhdr_int
->s_relptr
,
978 scnhdr_ext
->s_relptr
);
979 PUT_SCNHDR_LNNOPTR (abfd
, scnhdr_int
->s_lnnoptr
,
980 scnhdr_ext
->s_lnnoptr
);
983 /* Extra flags must be set when dealing with PE. All sections should also
984 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
985 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
986 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
987 (this is especially important when dealing with the .idata section since
988 the addresses for routines from .dlls must be overwritten). If .reloc
989 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
990 (0x02000000). Also, the resource data should also be read and
993 /* FIXME: Alignment is also encoded in this field, at least on
994 ARM-WINCE. Although - how do we get the original alignment field
999 char section_name
[SCNNMLEN
];
1000 unsigned long must_have
;
1002 pe_required_section_flags
;
1004 pe_required_section_flags known_sections
[] =
1006 { ".arch", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
| IMAGE_SCN_ALIGN_8BYTES
},
1007 { ".bss", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1008 { ".data", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1009 { ".edata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1010 { ".idata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1011 { ".pdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1012 { ".rdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1013 { ".reloc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
},
1014 { ".rsrc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1015 { ".text" , IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_CODE
| IMAGE_SCN_MEM_EXECUTE
},
1016 { ".tls", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1017 { ".xdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1020 pe_required_section_flags
* p
;
1022 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1023 we know exactly what this specific section wants so we remove it
1024 and then allow the must_have field to add it back in if necessary.
1025 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1026 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
1027 by ld --enable-auto-import (if auto-import is actually needed),
1028 by ld --omagic, or by obcopy --writable-text. */
1030 for (p
= known_sections
;
1031 p
< known_sections
+ ARRAY_SIZE (known_sections
);
1033 if (memcmp (scnhdr_int
->s_name
, p
->section_name
, SCNNMLEN
) == 0)
1035 if (memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text")
1036 || (bfd_get_file_flags (abfd
) & WP_TEXT
))
1037 scnhdr_int
->s_flags
&= ~IMAGE_SCN_MEM_WRITE
;
1038 scnhdr_int
->s_flags
|= p
->must_have
;
1042 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1045 if (coff_data (abfd
)->link_info
1046 && ! bfd_link_relocatable (coff_data (abfd
)->link_info
)
1047 && ! bfd_link_pic (coff_data (abfd
)->link_info
)
1048 && memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text") == 0)
1050 /* By inference from looking at MS output, the 32 bit field
1051 which is the combination of the number_of_relocs and
1052 number_of_linenos is used for the line number count in
1053 executables. A 16-bit field won't do for cc1. The MS
1054 document says that the number of relocs is zero for
1055 executables, but the 17-th bit has been observed to be there.
1056 Overflow is not an issue: a 4G-line program will overflow a
1057 bunch of other fields long before this! */
1058 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
& 0xffff), scnhdr_ext
->s_nlnno
);
1059 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
>> 16), scnhdr_ext
->s_nreloc
);
1063 if (scnhdr_int
->s_nlnno
<= 0xffff)
1064 H_PUT_16 (abfd
, scnhdr_int
->s_nlnno
, scnhdr_ext
->s_nlnno
);
1067 /* xgettext:c-format */
1068 _bfd_error_handler (_("%pB: line number overflow: 0x%lx > 0xffff"),
1069 abfd
, scnhdr_int
->s_nlnno
);
1070 bfd_set_error (bfd_error_file_truncated
);
1071 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nlnno
);
1075 /* Although we could encode 0xffff relocs here, we do not, to be
1076 consistent with other parts of bfd. Also it lets us warn, as
1077 we should never see 0xffff here w/o having the overflow flag
1079 if (scnhdr_int
->s_nreloc
< 0xffff)
1080 H_PUT_16 (abfd
, scnhdr_int
->s_nreloc
, scnhdr_ext
->s_nreloc
);
1083 /* PE can deal with large #s of relocs, but not here. */
1084 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nreloc
);
1085 scnhdr_int
->s_flags
|= IMAGE_SCN_LNK_NRELOC_OVFL
;
1086 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1093 _bfd_XXi_swap_debugdir_in (bfd
* abfd
, void * ext1
, void * in1
)
1095 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) ext1
;
1096 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) in1
;
1098 in
->Characteristics
= H_GET_32(abfd
, ext
->Characteristics
);
1099 in
->TimeDateStamp
= H_GET_32(abfd
, ext
->TimeDateStamp
);
1100 in
->MajorVersion
= H_GET_16(abfd
, ext
->MajorVersion
);
1101 in
->MinorVersion
= H_GET_16(abfd
, ext
->MinorVersion
);
1102 in
->Type
= H_GET_32(abfd
, ext
->Type
);
1103 in
->SizeOfData
= H_GET_32(abfd
, ext
->SizeOfData
);
1104 in
->AddressOfRawData
= H_GET_32(abfd
, ext
->AddressOfRawData
);
1105 in
->PointerToRawData
= H_GET_32(abfd
, ext
->PointerToRawData
);
1109 _bfd_XXi_swap_debugdir_out (bfd
* abfd
, void * inp
, void * extp
)
1111 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) extp
;
1112 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) inp
;
1114 H_PUT_32(abfd
, in
->Characteristics
, ext
->Characteristics
);
1115 H_PUT_32(abfd
, in
->TimeDateStamp
, ext
->TimeDateStamp
);
1116 H_PUT_16(abfd
, in
->MajorVersion
, ext
->MajorVersion
);
1117 H_PUT_16(abfd
, in
->MinorVersion
, ext
->MinorVersion
);
1118 H_PUT_32(abfd
, in
->Type
, ext
->Type
);
1119 H_PUT_32(abfd
, in
->SizeOfData
, ext
->SizeOfData
);
1120 H_PUT_32(abfd
, in
->AddressOfRawData
, ext
->AddressOfRawData
);
1121 H_PUT_32(abfd
, in
->PointerToRawData
, ext
->PointerToRawData
);
1123 return sizeof (struct external_IMAGE_DEBUG_DIRECTORY
);
1127 _bfd_XXi_slurp_codeview_record (bfd
* abfd
, file_ptr where
, unsigned long length
, CODEVIEW_INFO
*cvinfo
,
1131 bfd_size_type nread
;
1133 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1136 if (length
<= sizeof (CV_INFO_PDB70
) && length
<= sizeof (CV_INFO_PDB20
))
1140 nread
= bfd_read (buffer
, length
, abfd
);
1141 if (length
!= nread
)
1144 /* Ensure null termination of filename. */
1145 memset (buffer
+ nread
, 0, sizeof (buffer
) - nread
);
1147 cvinfo
->CVSignature
= H_GET_32 (abfd
, buffer
);
1150 if ((cvinfo
->CVSignature
== CVINFO_PDB70_CVSIGNATURE
)
1151 && (length
> sizeof (CV_INFO_PDB70
)))
1153 CV_INFO_PDB70
*cvinfo70
= (CV_INFO_PDB70
*)(buffer
);
1155 cvinfo
->Age
= H_GET_32(abfd
, cvinfo70
->Age
);
1157 /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1158 by 8 single bytes. Byte swap them so we can conveniently treat the GUID
1159 as 16 bytes in big-endian order. */
1160 bfd_putb32 (bfd_getl32 (cvinfo70
->Signature
), cvinfo
->Signature
);
1161 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[4])), &(cvinfo
->Signature
[4]));
1162 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[6])), &(cvinfo
->Signature
[6]));
1163 memcpy (&(cvinfo
->Signature
[8]), &(cvinfo70
->Signature
[8]), 8);
1165 cvinfo
->SignatureLength
= CV_INFO_SIGNATURE_LENGTH
;
1166 /* cvinfo->PdbFileName = cvinfo70->PdbFileName; */
1169 *pdb
= xstrdup (cvinfo70
->PdbFileName
);
1173 else if ((cvinfo
->CVSignature
== CVINFO_PDB20_CVSIGNATURE
)
1174 && (length
> sizeof (CV_INFO_PDB20
)))
1176 CV_INFO_PDB20
*cvinfo20
= (CV_INFO_PDB20
*)(buffer
);
1177 cvinfo
->Age
= H_GET_32(abfd
, cvinfo20
->Age
);
1178 memcpy (cvinfo
->Signature
, cvinfo20
->Signature
, 4);
1179 cvinfo
->SignatureLength
= 4;
1180 /* cvinfo->PdbFileName = cvinfo20->PdbFileName; */
1183 *pdb
= xstrdup (cvinfo20
->PdbFileName
);
1192 _bfd_XXi_write_codeview_record (bfd
* abfd
, file_ptr where
, CODEVIEW_INFO
*cvinfo
,
1195 size_t pdb_len
= pdb
? strlen (pdb
) : 0;
1196 const bfd_size_type size
= sizeof (CV_INFO_PDB70
) + pdb_len
+ 1;
1197 bfd_size_type written
;
1198 CV_INFO_PDB70
*cvinfo70
;
1201 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1204 buffer
= bfd_malloc (size
);
1208 cvinfo70
= (CV_INFO_PDB70
*) buffer
;
1209 H_PUT_32 (abfd
, CVINFO_PDB70_CVSIGNATURE
, cvinfo70
->CvSignature
);
1211 /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1212 in little-endian order, followed by 8 single bytes. */
1213 bfd_putl32 (bfd_getb32 (cvinfo
->Signature
), cvinfo70
->Signature
);
1214 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[4])), &(cvinfo70
->Signature
[4]));
1215 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[6])), &(cvinfo70
->Signature
[6]));
1216 memcpy (&(cvinfo70
->Signature
[8]), &(cvinfo
->Signature
[8]), 8);
1218 H_PUT_32 (abfd
, cvinfo
->Age
, cvinfo70
->Age
);
1221 cvinfo70
->PdbFileName
[0] = '\0';
1223 memcpy (cvinfo70
->PdbFileName
, pdb
, pdb_len
+ 1);
1225 written
= bfd_write (buffer
, size
, abfd
);
1229 return written
== size
? size
: 0;
1232 static char * dir_names
[IMAGE_NUMBEROF_DIRECTORY_ENTRIES
] =
1234 N_("Export Directory [.edata (or where ever we found it)]"),
1235 N_("Import Directory [parts of .idata]"),
1236 N_("Resource Directory [.rsrc]"),
1237 N_("Exception Directory [.pdata]"),
1238 N_("Security Directory"),
1239 N_("Base Relocation Directory [.reloc]"),
1240 N_("Debug Directory"),
1241 N_("Description Directory"),
1242 N_("Special Directory"),
1243 N_("Thread Storage Directory [.tls]"),
1244 N_("Load Configuration Directory"),
1245 N_("Bound Import Directory"),
1246 N_("Import Address Table Directory"),
1247 N_("Delay Import Directory"),
1248 N_("CLR Runtime Header"),
1253 get_contents_sanity_check (bfd
*abfd
, asection
*section
,
1254 bfd_size_type dataoff
, bfd_size_type datasize
)
1256 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
1258 if (dataoff
> section
->size
1259 || datasize
> section
->size
- dataoff
)
1261 ufile_ptr filesize
= bfd_get_file_size (abfd
);
1263 && ((ufile_ptr
) section
->filepos
> filesize
1264 || dataoff
> filesize
- section
->filepos
1265 || datasize
> filesize
- section
->filepos
- dataoff
))
1271 pe_print_idata (bfd
* abfd
, void * vfile
)
1273 FILE *file
= (FILE *) vfile
;
1277 bfd_size_type datasize
= 0;
1278 bfd_size_type dataoff
;
1282 pe_data_type
*pe
= pe_data (abfd
);
1283 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1287 addr
= extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
;
1289 if (addr
== 0 && extra
->DataDirectory
[PE_IMPORT_TABLE
].Size
== 0)
1291 /* Maybe the extra header isn't there. Look for the section. */
1292 section
= bfd_get_section_by_name (abfd
, ".idata");
1293 if (section
== NULL
|| (section
->flags
& SEC_HAS_CONTENTS
) == 0)
1296 addr
= section
->vma
;
1297 datasize
= section
->size
;
1303 addr
+= extra
->ImageBase
;
1304 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1306 datasize
= section
->size
;
1307 if (addr
>= section
->vma
&& addr
< section
->vma
+ datasize
)
1311 if (section
== NULL
)
1314 _("\nThere is an import table, but the section containing it could not be found\n"));
1317 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1320 _("\nThere is an import table in %s, but that section has no contents\n"),
1326 /* xgettext:c-format */
1327 fprintf (file
, _("\nThere is an import table in %s at 0x%lx\n"),
1328 section
->name
, (unsigned long) addr
);
1330 dataoff
= addr
- section
->vma
;
1333 _("\nThe Import Tables (interpreted %s section contents)\n"),
1337 vma: Hint Time Forward DLL First\n\
1338 Table Stamp Chain Name Thunk\n"));
1340 /* Read the whole section. Some of the fields might be before dataoff. */
1341 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
1347 adj
= section
->vma
- extra
->ImageBase
;
1349 /* Print all image import descriptors. */
1350 for (i
= dataoff
; i
+ onaline
<= datasize
; i
+= onaline
)
1354 bfd_vma forward_chain
;
1356 bfd_vma first_thunk
;
1361 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1362 fprintf (file
, " %08lx\t", (unsigned long) (i
+ adj
));
1363 hint_addr
= bfd_get_32 (abfd
, data
+ i
);
1364 time_stamp
= bfd_get_32 (abfd
, data
+ i
+ 4);
1365 forward_chain
= bfd_get_32 (abfd
, data
+ i
+ 8);
1366 dll_name
= bfd_get_32 (abfd
, data
+ i
+ 12);
1367 first_thunk
= bfd_get_32 (abfd
, data
+ i
+ 16);
1369 fprintf (file
, "%08lx %08lx %08lx %08lx %08lx\n",
1370 (unsigned long) hint_addr
,
1371 (unsigned long) time_stamp
,
1372 (unsigned long) forward_chain
,
1373 (unsigned long) dll_name
,
1374 (unsigned long) first_thunk
);
1376 if (hint_addr
== 0 && first_thunk
== 0)
1379 if (dll_name
- adj
>= section
->size
)
1382 dll
= (char *) data
+ dll_name
- adj
;
1383 /* PR 17512 file: 078-12277-0.004. */
1384 bfd_size_type maxlen
= (char *)(data
+ datasize
) - dll
- 1;
1385 fprintf (file
, _("\n\tDLL Name: %.*s\n"), (int) maxlen
, dll
);
1387 /* PR 21546: When the Hint Address is zero,
1388 we try the First Thunk instead. */
1390 hint_addr
= first_thunk
;
1392 if (hint_addr
!= 0 && hint_addr
- adj
< datasize
)
1395 asection
*ft_section
;
1397 bfd_size_type ft_datasize
;
1401 fprintf (file
, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1403 idx
= hint_addr
- adj
;
1405 ft_addr
= first_thunk
+ extra
->ImageBase
;
1406 ft_idx
= first_thunk
- adj
;
1407 ft_data
= data
+ ft_idx
;
1408 ft_datasize
= datasize
- ft_idx
;
1411 if (first_thunk
!= hint_addr
)
1413 /* Find the section which contains the first thunk. */
1414 for (ft_section
= abfd
->sections
;
1416 ft_section
= ft_section
->next
)
1418 if (ft_addr
>= ft_section
->vma
1419 && ft_addr
< ft_section
->vma
+ ft_section
->size
)
1423 if (ft_section
== NULL
)
1426 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1430 /* Now check to see if this section is the same as our current
1431 section. If it is not then we will have to load its data in. */
1432 if (ft_section
!= section
)
1434 ft_idx
= first_thunk
- (ft_section
->vma
- extra
->ImageBase
);
1435 ft_datasize
= ft_section
->size
- ft_idx
;
1436 if (!get_contents_sanity_check (abfd
, ft_section
,
1437 ft_idx
, ft_datasize
))
1439 ft_data
= (bfd_byte
*) bfd_malloc (ft_datasize
);
1440 if (ft_data
== NULL
)
1443 /* Read ft_datasize bytes starting at offset ft_idx. */
1444 if (!bfd_get_section_contents (abfd
, ft_section
, ft_data
,
1445 (bfd_vma
) ft_idx
, ft_datasize
))
1454 /* Print HintName vector entries. */
1455 #ifdef COFF_WITH_pex64
1456 for (j
= 0; idx
+ j
+ 8 <= datasize
; j
+= 8)
1459 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1460 unsigned long member_high
= bfd_get_32 (abfd
, data
+ idx
+ j
+ 4);
1462 if (!member
&& !member_high
)
1467 if (HighBitSet (member_high
))
1468 fprintf (file
, "\t%lx%08lx\t %4lx%08lx <none>",
1469 member_high
, member
,
1470 WithoutHighBit (member_high
), member
);
1471 /* PR binutils/17512: Handle corrupt PE data. */
1472 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1473 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1479 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1480 member_name
= (char *) data
+ amt
+ 2;
1481 fprintf (file
, "\t%04lx\t %4d %.*s",member
, ordinal
,
1482 (int) (datasize
- (amt
+ 2)), member_name
);
1485 /* If the time stamp is not zero, the import address
1486 table holds actual addresses. */
1489 && first_thunk
!= hint_addr
1490 && j
+ 4 <= ft_datasize
)
1491 fprintf (file
, "\t%04lx",
1492 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1493 fprintf (file
, "\n");
1496 for (j
= 0; idx
+ j
+ 4 <= datasize
; j
+= 4)
1499 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1501 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1507 if (HighBitSet (member
))
1508 fprintf (file
, "\t%04lx\t %4lu <none>",
1509 member
, WithoutHighBit (member
));
1510 /* PR binutils/17512: Handle corrupt PE data. */
1511 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1512 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1518 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1519 member_name
= (char *) data
+ amt
+ 2;
1520 fprintf (file
, "\t%04lx\t %4d %.*s",
1522 (int) (datasize
- (amt
+ 2)), member_name
);
1525 /* If the time stamp is not zero, the import address
1526 table holds actual addresses. */
1529 && first_thunk
!= hint_addr
1530 && j
+ 4 <= ft_datasize
)
1531 fprintf (file
, "\t%04lx",
1532 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1534 fprintf (file
, "\n");
1541 fprintf (file
, "\n");
1550 pe_print_edata (bfd
* abfd
, void * vfile
)
1552 FILE *file
= (FILE *) vfile
;
1555 bfd_size_type datasize
= 0;
1556 bfd_size_type dataoff
;
1561 long export_flags
; /* Reserved - should be zero. */
1565 bfd_vma name
; /* RVA - relative to image base. */
1566 long base
; /* Ordinal base. */
1567 unsigned long num_functions
;/* Number in the export address table. */
1568 unsigned long num_names
; /* Number in the name pointer table. */
1569 bfd_vma eat_addr
; /* RVA to the export address table. */
1570 bfd_vma npt_addr
; /* RVA to the Export Name Pointer Table. */
1571 bfd_vma ot_addr
; /* RVA to the Ordinal Table. */
1574 pe_data_type
*pe
= pe_data (abfd
);
1575 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1579 addr
= extra
->DataDirectory
[PE_EXPORT_TABLE
].VirtualAddress
;
1581 if (addr
== 0 && extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
== 0)
1583 /* Maybe the extra header isn't there. Look for the section. */
1584 section
= bfd_get_section_by_name (abfd
, ".edata");
1585 if (section
== NULL
)
1588 addr
= section
->vma
;
1590 datasize
= section
->size
;
1596 addr
+= extra
->ImageBase
;
1598 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1599 if (addr
>= section
->vma
&& addr
< section
->vma
+ section
->size
)
1602 if (section
== NULL
)
1605 _("\nThere is an export table, but the section containing it could not be found\n"));
1609 dataoff
= addr
- section
->vma
;
1610 datasize
= extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
;
1613 /* PR 17512: Handle corrupt PE binaries. */
1617 /* xgettext:c-format */
1618 _("\nThere is an export table in %s, but it is too small (%d)\n"),
1619 section
->name
, (int) datasize
);
1623 if (!get_contents_sanity_check (abfd
, section
, dataoff
, datasize
))
1626 _("\nThere is an export table in %s, but contents cannot be read\n"),
1631 /* xgettext:c-format */
1632 fprintf (file
, _("\nThere is an export table in %s at 0x%lx\n"),
1633 section
->name
, (unsigned long) addr
);
1635 data
= (bfd_byte
*) bfd_malloc (datasize
);
1639 if (! bfd_get_section_contents (abfd
, section
, data
,
1640 (file_ptr
) dataoff
, datasize
))
1646 /* Go get Export Directory Table. */
1647 edt
.export_flags
= bfd_get_32 (abfd
, data
+ 0);
1648 edt
.time_stamp
= bfd_get_32 (abfd
, data
+ 4);
1649 edt
.major_ver
= bfd_get_16 (abfd
, data
+ 8);
1650 edt
.minor_ver
= bfd_get_16 (abfd
, data
+ 10);
1651 edt
.name
= bfd_get_32 (abfd
, data
+ 12);
1652 edt
.base
= bfd_get_32 (abfd
, data
+ 16);
1653 edt
.num_functions
= bfd_get_32 (abfd
, data
+ 20);
1654 edt
.num_names
= bfd_get_32 (abfd
, data
+ 24);
1655 edt
.eat_addr
= bfd_get_32 (abfd
, data
+ 28);
1656 edt
.npt_addr
= bfd_get_32 (abfd
, data
+ 32);
1657 edt
.ot_addr
= bfd_get_32 (abfd
, data
+ 36);
1659 adj
= section
->vma
- extra
->ImageBase
+ dataoff
;
1661 /* Dump the EDT first. */
1663 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1667 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt
.export_flags
);
1670 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt
.time_stamp
);
1673 /* xgettext:c-format */
1674 _("Major/Minor \t\t\t%d/%d\n"), edt
.major_ver
, edt
.minor_ver
);
1677 _("Name \t\t\t\t"));
1678 bfd_fprintf_vma (abfd
, file
, edt
.name
);
1680 if ((edt
.name
>= adj
) && (edt
.name
< adj
+ datasize
))
1681 fprintf (file
, " %.*s\n",
1682 (int) (datasize
- (edt
.name
- adj
)),
1683 data
+ edt
.name
- adj
);
1685 fprintf (file
, "(outside .edata section)\n");
1688 _("Ordinal Base \t\t\t%ld\n"), edt
.base
);
1694 _("\tExport Address Table \t\t%08lx\n"),
1698 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt
.num_names
);
1701 _("Table Addresses\n"));
1704 _("\tExport Address Table \t\t"));
1705 bfd_fprintf_vma (abfd
, file
, edt
.eat_addr
);
1706 fprintf (file
, "\n");
1709 _("\tName Pointer Table \t\t"));
1710 bfd_fprintf_vma (abfd
, file
, edt
.npt_addr
);
1711 fprintf (file
, "\n");
1714 _("\tOrdinal Table \t\t\t"));
1715 bfd_fprintf_vma (abfd
, file
, edt
.ot_addr
);
1716 fprintf (file
, "\n");
1718 /* The next table to find is the Export Address Table. It's basically
1719 a list of pointers that either locate a function in this dll, or
1720 forward the call to another dll. Something like:
1725 } export_address_table_entry; */
1728 _("\nExport Address Table -- Ordinal Base %ld\n"),
1731 /* PR 17512: Handle corrupt PE binaries. */
1732 /* PR 17512 file: 140-165018-0.004. */
1733 if (edt
.eat_addr
- adj
>= datasize
1734 /* PR 17512: file: 092b1829 */
1735 || (edt
.num_functions
+ 1) * 4 < edt
.num_functions
1736 || edt
.eat_addr
- adj
+ (edt
.num_functions
+ 1) * 4 > datasize
)
1737 fprintf (file
, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1738 (long) edt
.eat_addr
,
1739 (long) edt
.num_functions
);
1740 else for (i
= 0; i
< edt
.num_functions
; ++i
)
1742 bfd_vma eat_member
= bfd_get_32 (abfd
,
1743 data
+ edt
.eat_addr
+ (i
* 4) - adj
);
1744 if (eat_member
== 0)
1747 if (eat_member
- adj
<= datasize
)
1749 /* This rva is to a name (forwarding function) in our section. */
1750 /* Should locate a function descriptor. */
1752 "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1754 (long) (i
+ edt
.base
),
1755 (unsigned long) eat_member
,
1757 (int)(datasize
- (eat_member
- adj
)),
1758 data
+ eat_member
- adj
);
1762 /* Should locate a function descriptor in the reldata section. */
1764 "\t[%4ld] +base[%4ld] %04lx %s\n",
1766 (long) (i
+ edt
.base
),
1767 (unsigned long) eat_member
,
1772 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1773 /* Dump them in parallel for clarity. */
1775 _("\n[Ordinal/Name Pointer] Table\n"));
1777 /* PR 17512: Handle corrupt PE binaries. */
1778 if (edt
.npt_addr
+ (edt
.num_names
* 4) - adj
>= datasize
1779 /* PR 17512: file: bb68816e. */
1780 || edt
.num_names
* 4 < edt
.num_names
1781 || (data
+ edt
.npt_addr
- adj
) < data
)
1782 /* xgettext:c-format */
1783 fprintf (file
, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1784 (long) edt
.npt_addr
,
1785 (long) edt
.num_names
);
1786 /* PR 17512: file: 140-147171-0.004. */
1787 else if (edt
.ot_addr
+ (edt
.num_names
* 2) - adj
>= datasize
1788 || data
+ edt
.ot_addr
- adj
< data
)
1789 /* xgettext:c-format */
1790 fprintf (file
, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1792 (long) edt
.num_names
);
1793 else for (i
= 0; i
< edt
.num_names
; ++i
)
1798 ord
= bfd_get_16 (abfd
, data
+ edt
.ot_addr
+ (i
* 2) - adj
);
1799 name_ptr
= bfd_get_32 (abfd
, data
+ edt
.npt_addr
+ (i
* 4) - adj
);
1801 if ((name_ptr
- adj
) >= datasize
)
1803 /* xgettext:c-format */
1804 fprintf (file
, _("\t[%4ld] <corrupt offset: %lx>\n"),
1805 (long) ord
, (long) name_ptr
);
1809 char * name
= (char *) data
+ name_ptr
- adj
;
1811 fprintf (file
, "\t[%4ld] %.*s\n", (long) ord
,
1812 (int)((char *)(data
+ datasize
) - name
), name
);
1821 /* This really is architecture dependent. On IA-64, a .pdata entry
1822 consists of three dwords containing relative virtual addresses that
1823 specify the start and end address of the code range the entry
1824 covers and the address of the corresponding unwind info data.
1826 On ARM and SH-4, a compressed PDATA structure is used :
1827 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1828 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1829 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1831 This is the version for uncompressed data. */
1834 pe_print_pdata (bfd
* abfd
, void * vfile
)
1836 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
1837 # define PDATA_ROW_SIZE (3 * 8)
1839 # define PDATA_ROW_SIZE (5 * 4)
1841 FILE *file
= (FILE *) vfile
;
1843 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1844 bfd_size_type datasize
= 0;
1846 bfd_size_type start
, stop
;
1847 int onaline
= PDATA_ROW_SIZE
;
1850 || (section
->flags
& SEC_HAS_CONTENTS
) == 0
1851 || coff_section_data (abfd
, section
) == NULL
1852 || pei_section_data (abfd
, section
) == NULL
)
1855 stop
= pei_section_data (abfd
, section
)->virt_size
;
1856 if ((stop
% onaline
) != 0)
1858 /* xgettext:c-format */
1859 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
1860 (long) stop
, onaline
);
1863 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1864 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
1866 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1869 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1870 \t\tAddress Address Handler Data Address Mask\n"));
1873 datasize
= section
->size
;
1877 /* PR 17512: file: 002-193900-0.004. */
1878 if (datasize
< stop
)
1880 /* xgettext:c-format */
1881 fprintf (file
, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"),
1882 (long) stop
, (long) datasize
);
1886 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
1894 for (i
= start
; i
< stop
; i
+= onaline
)
1900 bfd_vma prolog_end_addr
;
1901 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64)
1905 if (i
+ PDATA_ROW_SIZE
> stop
)
1908 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
1909 end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
1910 eh_handler
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 8);
1911 eh_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 12);
1912 prolog_end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 16);
1914 if (begin_addr
== 0 && end_addr
== 0 && eh_handler
== 0
1915 && eh_data
== 0 && prolog_end_addr
== 0)
1916 /* We are probably into the padding of the section now. */
1919 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64)
1920 em_data
= ((eh_handler
& 0x1) << 2) | (prolog_end_addr
& 0x3);
1922 eh_handler
&= ~(bfd_vma
) 0x3;
1923 prolog_end_addr
&= ~(bfd_vma
) 0x3;
1926 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
1927 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
1928 bfd_fprintf_vma (abfd
, file
, end_addr
); fputc (' ', file
);
1929 bfd_fprintf_vma (abfd
, file
, eh_handler
);
1930 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64)
1932 bfd_fprintf_vma (abfd
, file
, eh_data
); fputc (' ', file
);
1933 bfd_fprintf_vma (abfd
, file
, prolog_end_addr
);
1934 fprintf (file
, " %x", em_data
);
1936 fprintf (file
, "\n");
1942 #undef PDATA_ROW_SIZE
1945 typedef struct sym_cache
1952 slurp_symtab (bfd
*abfd
, sym_cache
*psc
)
1954 asymbol
** sy
= NULL
;
1957 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1963 storage
= bfd_get_symtab_upper_bound (abfd
);
1968 sy
= (asymbol
**) bfd_malloc (storage
);
1973 psc
->symcount
= bfd_canonicalize_symtab (abfd
, sy
);
1974 if (psc
->symcount
< 0)
1980 my_symbol_for_address (bfd
*abfd
, bfd_vma func
, sym_cache
*psc
)
1985 psc
->syms
= slurp_symtab (abfd
, psc
);
1987 for (i
= 0; i
< psc
->symcount
; i
++)
1989 if (psc
->syms
[i
]->section
->vma
+ psc
->syms
[i
]->value
== func
)
1990 return psc
->syms
[i
]->name
;
1997 cleanup_syms (sym_cache
*psc
)
2004 /* This is the version for "compressed" pdata. */
2007 _bfd_XX_print_ce_compressed_pdata (bfd
* abfd
, void * vfile
)
2009 # define PDATA_ROW_SIZE (2 * 4)
2010 FILE *file
= (FILE *) vfile
;
2011 bfd_byte
*data
= NULL
;
2012 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
2013 bfd_size_type datasize
= 0;
2015 bfd_size_type start
, stop
;
2016 int onaline
= PDATA_ROW_SIZE
;
2017 struct sym_cache cache
= {0, 0} ;
2020 || (section
->flags
& SEC_HAS_CONTENTS
) == 0
2021 || coff_section_data (abfd
, section
) == NULL
2022 || pei_section_data (abfd
, section
) == NULL
)
2025 stop
= pei_section_data (abfd
, section
)->virt_size
;
2026 if ((stop
% onaline
) != 0)
2028 /* xgettext:c-format */
2029 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
2030 (long) stop
, onaline
);
2033 _("\nThe Function Table (interpreted .pdata section contents)\n"));
2036 vma:\t\tBegin Prolog Function Flags Exception EH\n\
2037 \t\tAddress Length Length 32b exc Handler Data\n"));
2039 datasize
= section
->size
;
2043 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2050 if (stop
> datasize
)
2053 for (i
= start
; i
< stop
; i
+= onaline
)
2057 bfd_vma prolog_length
, function_length
;
2058 int flag32bit
, exception_flag
;
2061 if (i
+ PDATA_ROW_SIZE
> stop
)
2064 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
2065 other_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
2067 if (begin_addr
== 0 && other_data
== 0)
2068 /* We are probably into the padding of the section now. */
2071 prolog_length
= (other_data
& 0x000000FF);
2072 function_length
= (other_data
& 0x3FFFFF00) >> 8;
2073 flag32bit
= (int)((other_data
& 0x40000000) >> 30);
2074 exception_flag
= (int)((other_data
& 0x80000000) >> 31);
2077 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
2078 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
2079 bfd_fprintf_vma (abfd
, file
, prolog_length
); fputc (' ', file
);
2080 bfd_fprintf_vma (abfd
, file
, function_length
); fputc (' ', file
);
2081 fprintf (file
, "%2d %2d ", flag32bit
, exception_flag
);
2083 /* Get the exception handler's address and the data passed from the
2084 .text section. This is really the data that belongs with the .pdata
2085 but got "compressed" out for the ARM and SH4 architectures. */
2086 tsection
= bfd_get_section_by_name (abfd
, ".text");
2087 if (tsection
&& coff_section_data (abfd
, tsection
)
2088 && pei_section_data (abfd
, tsection
))
2090 bfd_vma eh_off
= (begin_addr
- 8) - tsection
->vma
;
2093 tdata
= (bfd_byte
*) bfd_malloc (8);
2096 if (bfd_get_section_contents (abfd
, tsection
, tdata
, eh_off
, 8))
2098 bfd_vma eh
, eh_data
;
2100 eh
= bfd_get_32 (abfd
, tdata
);
2101 eh_data
= bfd_get_32 (abfd
, tdata
+ 4);
2102 fprintf (file
, "%08x ", (unsigned int) eh
);
2103 fprintf (file
, "%08x", (unsigned int) eh_data
);
2106 const char *s
= my_symbol_for_address (abfd
, eh
, &cache
);
2109 fprintf (file
, " (%s) ", s
);
2116 fprintf (file
, "\n");
2121 cleanup_syms (& cache
);
2124 #undef PDATA_ROW_SIZE
2128 #define IMAGE_REL_BASED_HIGHADJ 4
2129 static const char * const tbl
[] =
2143 "UNKNOWN", /* MUST be last. */
2147 pe_print_reloc (bfd
* abfd
, void * vfile
)
2149 FILE *file
= (FILE *) vfile
;
2151 asection
*section
= bfd_get_section_by_name (abfd
, ".reloc");
2155 || section
->size
== 0
2156 || (section
->flags
& SEC_HAS_CONTENTS
) == 0)
2160 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2162 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2169 end
= data
+ section
->size
;
2170 while (p
+ 8 <= end
)
2173 bfd_vma virtual_address
;
2174 unsigned long number
, size
;
2175 bfd_byte
*chunk_end
;
2177 /* The .reloc section is a sequence of blocks, with a header consisting
2178 of two 32 bit quantities, followed by a number of 16 bit entries. */
2179 virtual_address
= bfd_get_32 (abfd
, p
);
2180 size
= bfd_get_32 (abfd
, p
+ 4);
2182 number
= (size
- 8) / 2;
2188 /* xgettext:c-format */
2189 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2190 (unsigned long) virtual_address
, size
, size
, number
);
2192 chunk_end
= p
- 8 + size
;
2193 if (chunk_end
> end
)
2196 while (p
+ 2 <= chunk_end
)
2198 unsigned short e
= bfd_get_16 (abfd
, p
);
2199 unsigned int t
= (e
& 0xF000) >> 12;
2200 int off
= e
& 0x0FFF;
2202 if (t
>= sizeof (tbl
) / sizeof (tbl
[0]))
2203 t
= (sizeof (tbl
) / sizeof (tbl
[0])) - 1;
2206 /* xgettext:c-format */
2207 _("\treloc %4d offset %4x [%4lx] %s"),
2208 j
, off
, (unsigned long) (off
+ virtual_address
), tbl
[t
]);
2213 /* HIGHADJ takes an argument, - the next record *is* the
2214 low 16 bits of addend. */
2215 if (t
== IMAGE_REL_BASED_HIGHADJ
&& p
+ 2 <= chunk_end
)
2217 fprintf (file
, " (%4x)", (unsigned int) bfd_get_16 (abfd
, p
));
2222 fprintf (file
, "\n");
2231 /* A data structure describing the regions of a .rsrc section.
2232 Some fields are filled in as the section is parsed. */
2234 typedef struct rsrc_regions
2236 bfd_byte
* section_start
;
2237 bfd_byte
* section_end
;
2238 bfd_byte
* strings_start
;
2239 bfd_byte
* resource_start
;
2243 rsrc_print_resource_directory (FILE * , bfd
*, unsigned int, bfd_byte
*,
2244 rsrc_regions
*, bfd_vma
);
2246 /* Print the resource entry at DATA, with the text indented by INDENT.
2247 Recusively calls rsrc_print_resource_directory to print the contents
2248 of directory entries.
2249 Returns the address of the end of the data associated with the entry
2250 or section_end + 1 upon failure. */
2253 rsrc_print_resource_entries (FILE *file
,
2255 unsigned int indent
,
2258 rsrc_regions
*regions
,
2261 unsigned long entry
, addr
, size
;
2264 if (data
+ 8 >= regions
->section_end
)
2265 return regions
->section_end
+ 1;
2267 /* xgettext:c-format */
2268 fprintf (file
, _("%03x %*.s Entry: "), (int)(data
- regions
->section_start
), indent
, " ");
2270 entry
= (unsigned long) bfd_get_32 (abfd
, data
);
2275 /* Note - the documentation says that this field is an RVA value
2276 but windres appears to produce a section relative offset with
2277 the top bit set. Support both styles for now. */
2278 if (HighBitSet (entry
))
2279 name
= regions
->section_start
+ WithoutHighBit (entry
);
2281 name
= regions
->section_start
+ entry
- rva_bias
;
2283 if (name
+ 2 < regions
->section_end
&& name
> regions
->section_start
)
2287 if (regions
->strings_start
== NULL
)
2288 regions
->strings_start
= name
;
2290 len
= bfd_get_16 (abfd
, name
);
2292 fprintf (file
, _("name: [val: %08lx len %d]: "), entry
, len
);
2294 if (name
+ 2 + len
* 2 < regions
->section_end
)
2296 /* This strange loop is to cope with multibyte characters. */
2303 /* Avoid printing control characters. */
2304 if (c
> 0 && c
< 32)
2305 fprintf (file
, "^%c", c
+ 64);
2307 fprintf (file
, "%.1s", name
);
2312 fprintf (file
, _("<corrupt string length: %#x>\n"), len
);
2313 /* PR binutils/17512: Do not try to continue decoding a
2314 corrupted resource section. It is likely to end up with
2315 reams of extraneous output. FIXME: We could probably
2316 continue if we disable the printing of strings... */
2317 return regions
->section_end
+ 1;
2322 fprintf (file
, _("<corrupt string offset: %#lx>\n"), entry
);
2323 return regions
->section_end
+ 1;
2327 fprintf (file
, _("ID: %#08lx"), entry
);
2329 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
2330 fprintf (file
, _(", Value: %#08lx\n"), entry
);
2332 if (HighBitSet (entry
))
2334 data
= regions
->section_start
+ WithoutHighBit (entry
);
2335 if (data
<= regions
->section_start
|| data
> regions
->section_end
)
2336 return regions
->section_end
+ 1;
2338 /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2339 in the resource table. We need some way to detect this. */
2340 return rsrc_print_resource_directory (file
, abfd
, indent
+ 1, data
,
2344 leaf
= regions
->section_start
+ entry
;
2346 if (leaf
+ 16 >= regions
->section_end
2347 /* PR 17512: file: 055dff7e. */
2348 || leaf
< regions
->section_start
)
2349 return regions
->section_end
+ 1;
2351 /* xgettext:c-format */
2352 fprintf (file
, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2353 (int) (entry
), indent
, " ",
2354 addr
= (long) bfd_get_32 (abfd
, leaf
),
2355 size
= (long) bfd_get_32 (abfd
, leaf
+ 4),
2356 (int) bfd_get_32 (abfd
, leaf
+ 8));
2358 /* Check that the reserved entry is 0. */
2359 if (bfd_get_32 (abfd
, leaf
+ 12) != 0
2360 /* And that the data address/size is valid too. */
2361 || (regions
->section_start
+ (addr
- rva_bias
) + size
> regions
->section_end
))
2362 return regions
->section_end
+ 1;
2364 if (regions
->resource_start
== NULL
)
2365 regions
->resource_start
= regions
->section_start
+ (addr
- rva_bias
);
2367 return regions
->section_start
+ (addr
- rva_bias
) + size
;
2370 #define max(a,b) ((a) > (b) ? (a) : (b))
2371 #define min(a,b) ((a) < (b) ? (a) : (b))
2374 rsrc_print_resource_directory (FILE * file
,
2376 unsigned int indent
,
2378 rsrc_regions
* regions
,
2381 unsigned int num_names
, num_ids
;
2382 bfd_byte
* highest_data
= data
;
2384 if (data
+ 16 >= regions
->section_end
)
2385 return regions
->section_end
+ 1;
2387 fprintf (file
, "%03x %*.s ", (int)(data
- regions
->section_start
), indent
, " ");
2390 case 0: fprintf (file
, "Type"); break;
2391 case 2: fprintf (file
, "Name"); break;
2392 case 4: fprintf (file
, "Language"); break;
2394 fprintf (file
, _("<unknown directory type: %d>\n"), indent
);
2395 /* FIXME: For now we end the printing here. If in the
2396 future more directory types are added to the RSRC spec
2397 then we will need to change this. */
2398 return regions
->section_end
+ 1;
2401 /* xgettext:c-format */
2402 fprintf (file
, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2403 (int) bfd_get_32 (abfd
, data
),
2404 (long) bfd_get_32 (abfd
, data
+ 4),
2405 (int) bfd_get_16 (abfd
, data
+ 8),
2406 (int) bfd_get_16 (abfd
, data
+ 10),
2407 num_names
= (int) bfd_get_16 (abfd
, data
+ 12),
2408 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14));
2411 while (num_names
--)
2413 bfd_byte
* entry_end
;
2415 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, true,
2416 data
, regions
, rva_bias
);
2418 highest_data
= max (highest_data
, entry_end
);
2419 if (entry_end
>= regions
->section_end
)
2425 bfd_byte
* entry_end
;
2427 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, false,
2428 data
, regions
, rva_bias
);
2430 highest_data
= max (highest_data
, entry_end
);
2431 if (entry_end
>= regions
->section_end
)
2435 return max (highest_data
, data
);
2438 /* Display the contents of a .rsrc section. We do not try to
2439 reproduce the resources, windres does that. Instead we dump
2440 the tables in a human readable format. */
2443 rsrc_print_section (bfd
* abfd
, void * vfile
)
2447 FILE * file
= (FILE *) vfile
;
2448 bfd_size_type datasize
;
2451 rsrc_regions regions
;
2453 pe
= pe_data (abfd
);
2457 section
= bfd_get_section_by_name (abfd
, ".rsrc");
2458 if (section
== NULL
)
2460 if (!(section
->flags
& SEC_HAS_CONTENTS
))
2463 datasize
= section
->size
;
2467 rva_bias
= section
->vma
- pe
->pe_opthdr
.ImageBase
;
2469 if (! bfd_malloc_and_get_section (abfd
, section
, & data
))
2475 regions
.section_start
= data
;
2476 regions
.section_end
= data
+ datasize
;
2477 regions
.strings_start
= NULL
;
2478 regions
.resource_start
= NULL
;
2481 fprintf (file
, "\nThe .rsrc Resource Directory section:\n");
2483 while (data
< regions
.section_end
)
2485 bfd_byte
* p
= data
;
2487 data
= rsrc_print_resource_directory (file
, abfd
, 0, data
, & regions
, rva_bias
);
2489 if (data
== regions
.section_end
+ 1)
2490 fprintf (file
, _("Corrupt .rsrc section detected!\n"));
2493 /* Align data before continuing. */
2494 int align
= (1 << section
->alignment_power
) - 1;
2496 data
= (bfd_byte
*) (((ptrdiff_t) (data
+ align
)) & ~ align
);
2497 rva_bias
+= data
- p
;
2499 /* For reasons that are unclear .rsrc sections are sometimes created
2500 aligned to a 1^3 boundary even when their alignment is set at
2501 1^2. Catch that case here before we issue a spurious warning
2503 if (data
== (regions
.section_end
- 4))
2504 data
= regions
.section_end
;
2505 else if (data
< regions
.section_end
)
2507 /* If the extra data is all zeros then do not complain.
2508 This is just padding so that the section meets the
2509 page size requirements. */
2510 while (++ data
< regions
.section_end
)
2513 if (data
< regions
.section_end
)
2514 fprintf (file
, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2519 if (regions
.strings_start
!= NULL
)
2520 fprintf (file
, _(" String table starts at offset: %#03x\n"),
2521 (int) (regions
.strings_start
- regions
.section_start
));
2522 if (regions
.resource_start
!= NULL
)
2523 fprintf (file
, _(" Resources start at offset: %#03x\n"),
2524 (int) (regions
.resource_start
- regions
.section_start
));
2526 free (regions
.section_start
);
2530 #define IMAGE_NUMBEROF_DEBUG_TYPES 17
2532 static char * debug_type_names
[IMAGE_NUMBEROF_DEBUG_TYPES
] =
2554 pe_print_debugdata (bfd
* abfd
, void * vfile
)
2556 FILE *file
= (FILE *) vfile
;
2557 pe_data_type
*pe
= pe_data (abfd
);
2558 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2561 bfd_size_type dataoff
;
2564 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2565 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2570 addr
+= extra
->ImageBase
;
2571 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2573 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2577 if (section
== NULL
)
2580 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2583 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
2586 _("\nThere is a debug directory in %s, but that section has no contents\n"),
2590 else if (section
->size
< size
)
2593 _("\nError: section %s contains the debug data starting address but it is too small\n"),
2598 fprintf (file
, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2599 section
->name
, (unsigned long) addr
);
2601 dataoff
= addr
- section
->vma
;
2603 if (size
> (section
->size
- dataoff
))
2605 fprintf (file
, _("The debug data size field in the data directory is too big for the section"));
2610 _("Type Size Rva Offset\n"));
2612 /* Read the whole section. */
2613 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2619 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2621 const char *type_name
;
2622 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2623 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2624 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2626 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2628 if ((idd
.Type
) >= IMAGE_NUMBEROF_DEBUG_TYPES
)
2629 type_name
= debug_type_names
[0];
2631 type_name
= debug_type_names
[idd
.Type
];
2633 fprintf (file
, " %2ld %14s %08lx %08lx %08lx\n",
2634 idd
.Type
, type_name
, idd
.SizeOfData
,
2635 idd
.AddressOfRawData
, idd
.PointerToRawData
);
2637 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_CODEVIEW
)
2639 char signature
[CV_INFO_SIGNATURE_LENGTH
* 2 + 1];
2640 /* PR 17512: file: 065-29434-0.001:0.1
2641 We need to use a 32-bit aligned buffer
2642 to safely read in a codeview record. */
2643 char buffer
[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO
);
2646 CODEVIEW_INFO
*cvinfo
= (CODEVIEW_INFO
*) buffer
;
2648 /* The debug entry doesn't have to have to be in a section,
2649 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2650 if (!_bfd_XXi_slurp_codeview_record (abfd
, (file_ptr
) idd
.PointerToRawData
,
2651 idd
.SizeOfData
, cvinfo
, &pdb
))
2654 for (j
= 0; j
< cvinfo
->SignatureLength
; j
++)
2655 sprintf (&signature
[j
*2], "%02x", cvinfo
->Signature
[j
] & 0xff);
2657 /* xgettext:c-format */
2658 fprintf (file
, _("(format %c%c%c%c signature %s age %ld pdb %s)\n"),
2659 buffer
[0], buffer
[1], buffer
[2], buffer
[3],
2660 signature
, cvinfo
->Age
, pdb
[0] ? pdb
: "(none)");
2668 if (size
% sizeof (struct external_IMAGE_DEBUG_DIRECTORY
) != 0)
2670 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2676 pe_is_repro (bfd
* abfd
)
2678 pe_data_type
*pe
= pe_data (abfd
);
2679 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2682 bfd_size_type dataoff
;
2686 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2687 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2692 addr
+= extra
->ImageBase
;
2693 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2695 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2699 if ((section
== NULL
)
2700 || (!(section
->flags
& SEC_HAS_CONTENTS
))
2701 || (section
->size
< size
))
2706 dataoff
= addr
- section
->vma
;
2708 if (size
> (section
->size
- dataoff
))
2713 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2719 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2721 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2722 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2723 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2725 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2727 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_REPRO
)
2739 /* Print out the program headers. */
2742 _bfd_XX_print_private_bfd_data_common (bfd
* abfd
, void * vfile
)
2744 FILE *file
= (FILE *) vfile
;
2746 pe_data_type
*pe
= pe_data (abfd
);
2747 struct internal_extra_pe_aouthdr
*i
= &pe
->pe_opthdr
;
2748 const char *subsystem_name
= NULL
;
2751 /* The MS dumpbin program reportedly ands with 0xff0f before
2752 printing the characteristics field. Not sure why. No reason to
2754 fprintf (file
, _("\nCharacteristics 0x%x\n"), pe
->real_flags
);
2756 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2757 PF (IMAGE_FILE_RELOCS_STRIPPED
, "relocations stripped");
2758 PF (IMAGE_FILE_EXECUTABLE_IMAGE
, "executable");
2759 PF (IMAGE_FILE_LINE_NUMS_STRIPPED
, "line numbers stripped");
2760 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED
, "symbols stripped");
2761 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE
, "large address aware");
2762 PF (IMAGE_FILE_BYTES_REVERSED_LO
, "little endian");
2763 PF (IMAGE_FILE_32BIT_MACHINE
, "32 bit words");
2764 PF (IMAGE_FILE_DEBUG_STRIPPED
, "debugging information removed");
2765 PF (IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP
, "copy to swap file if on removable media");
2766 PF (IMAGE_FILE_NET_RUN_FROM_SWAP
, "copy to swap file if on network media");
2767 PF (IMAGE_FILE_SYSTEM
, "system file");
2768 PF (IMAGE_FILE_DLL
, "DLL");
2769 PF (IMAGE_FILE_UP_SYSTEM_ONLY
, "run only on uniprocessor machine");
2770 PF (IMAGE_FILE_BYTES_REVERSED_HI
, "big endian");
2774 If a PE_IMAGE_DEBUG_TYPE_REPRO entry is present in the debug directory, the
2775 timestamp is to be interpreted as the hash of a reproducible build.
2777 if (pe_is_repro (abfd
))
2779 fprintf (file
, "\nTime/Date\t\t%08lx", pe
->coff
.timestamp
);
2780 fprintf (file
, "\t(This is a reproducible build file hash, not a timestamp)\n");
2784 /* ctime implies '\n'. */
2785 time_t t
= pe
->coff
.timestamp
;
2786 fprintf (file
, "\nTime/Date\t\t%s", ctime (&t
));
2789 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2790 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2792 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2793 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2795 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2796 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2801 case IMAGE_NT_OPTIONAL_HDR_MAGIC
:
2804 case IMAGE_NT_OPTIONAL_HDR64_MAGIC
:
2807 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC
:
2814 fprintf (file
, "Magic\t\t\t%04x", i
->Magic
);
2816 fprintf (file
, "\t(%s)",name
);
2817 fprintf (file
, "\nMajorLinkerVersion\t%d\n", i
->MajorLinkerVersion
);
2818 fprintf (file
, "MinorLinkerVersion\t%d\n", i
->MinorLinkerVersion
);
2819 fprintf (file
, "SizeOfCode\t\t");
2820 bfd_fprintf_vma (abfd
, file
, i
->SizeOfCode
);
2821 fprintf (file
, "\nSizeOfInitializedData\t");
2822 bfd_fprintf_vma (abfd
, file
, i
->SizeOfInitializedData
);
2823 fprintf (file
, "\nSizeOfUninitializedData\t");
2824 bfd_fprintf_vma (abfd
, file
, i
->SizeOfUninitializedData
);
2825 fprintf (file
, "\nAddressOfEntryPoint\t");
2826 bfd_fprintf_vma (abfd
, file
, i
->AddressOfEntryPoint
);
2827 fprintf (file
, "\nBaseOfCode\t\t");
2828 bfd_fprintf_vma (abfd
, file
, i
->BaseOfCode
);
2829 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
2830 /* PE32+ does not have BaseOfData member! */
2831 fprintf (file
, "\nBaseOfData\t\t");
2832 bfd_fprintf_vma (abfd
, file
, i
->BaseOfData
);
2835 fprintf (file
, "\nImageBase\t\t");
2836 bfd_fprintf_vma (abfd
, file
, i
->ImageBase
);
2837 fprintf (file
, "\nSectionAlignment\t%08x\n", i
->SectionAlignment
);
2838 fprintf (file
, "FileAlignment\t\t%08x\n", i
->FileAlignment
);
2839 fprintf (file
, "MajorOSystemVersion\t%d\n", i
->MajorOperatingSystemVersion
);
2840 fprintf (file
, "MinorOSystemVersion\t%d\n", i
->MinorOperatingSystemVersion
);
2841 fprintf (file
, "MajorImageVersion\t%d\n", i
->MajorImageVersion
);
2842 fprintf (file
, "MinorImageVersion\t%d\n", i
->MinorImageVersion
);
2843 fprintf (file
, "MajorSubsystemVersion\t%d\n", i
->MajorSubsystemVersion
);
2844 fprintf (file
, "MinorSubsystemVersion\t%d\n", i
->MinorSubsystemVersion
);
2845 fprintf (file
, "Win32Version\t\t%08x\n", i
->Reserved1
);
2846 fprintf (file
, "SizeOfImage\t\t%08x\n", i
->SizeOfImage
);
2847 fprintf (file
, "SizeOfHeaders\t\t%08x\n", i
->SizeOfHeaders
);
2848 fprintf (file
, "CheckSum\t\t%08x\n", i
->CheckSum
);
2850 switch (i
->Subsystem
)
2852 case IMAGE_SUBSYSTEM_UNKNOWN
:
2853 subsystem_name
= "unspecified";
2855 case IMAGE_SUBSYSTEM_NATIVE
:
2856 subsystem_name
= "NT native";
2858 case IMAGE_SUBSYSTEM_WINDOWS_GUI
:
2859 subsystem_name
= "Windows GUI";
2861 case IMAGE_SUBSYSTEM_WINDOWS_CUI
:
2862 subsystem_name
= "Windows CUI";
2864 case IMAGE_SUBSYSTEM_POSIX_CUI
:
2865 subsystem_name
= "POSIX CUI";
2867 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI
:
2868 subsystem_name
= "Wince CUI";
2870 /* These are from UEFI Platform Initialization Specification 1.1. */
2871 case IMAGE_SUBSYSTEM_EFI_APPLICATION
:
2872 subsystem_name
= "EFI application";
2874 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
:
2875 subsystem_name
= "EFI boot service driver";
2877 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
:
2878 subsystem_name
= "EFI runtime driver";
2880 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER
:
2881 subsystem_name
= "SAL runtime driver";
2883 /* This is from revision 8.0 of the MS PE/COFF spec */
2884 case IMAGE_SUBSYSTEM_XBOX
:
2885 subsystem_name
= "XBOX";
2887 /* Added default case for clarity - subsystem_name is NULL anyway. */
2889 subsystem_name
= NULL
;
2892 fprintf (file
, "Subsystem\t\t%08x", i
->Subsystem
);
2894 fprintf (file
, "\t(%s)", subsystem_name
);
2895 fprintf (file
, "\nDllCharacteristics\t%08x\n", i
->DllCharacteristics
);
2896 if (i
->DllCharacteristics
)
2898 unsigned short dllch
= i
->DllCharacteristics
;
2899 const char *indent
= "\t\t\t\t\t";
2901 if (dllch
& IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA
)
2902 fprintf (file
, "%sHIGH_ENTROPY_VA\n", indent
);
2903 if (dllch
& IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE
)
2904 fprintf (file
, "%sDYNAMIC_BASE\n", indent
);
2905 if (dllch
& IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY
)
2906 fprintf (file
, "%sFORCE_INTEGRITY\n", indent
);
2907 if (dllch
& IMAGE_DLL_CHARACTERISTICS_NX_COMPAT
)
2908 fprintf (file
, "%sNX_COMPAT\n", indent
);
2909 if (dllch
& IMAGE_DLLCHARACTERISTICS_NO_ISOLATION
)
2910 fprintf (file
, "%sNO_ISOLATION\n", indent
);
2911 if (dllch
& IMAGE_DLLCHARACTERISTICS_NO_SEH
)
2912 fprintf (file
, "%sNO_SEH\n", indent
);
2913 if (dllch
& IMAGE_DLLCHARACTERISTICS_NO_BIND
)
2914 fprintf (file
, "%sNO_BIND\n", indent
);
2915 if (dllch
& IMAGE_DLLCHARACTERISTICS_APPCONTAINER
)
2916 fprintf (file
, "%sAPPCONTAINER\n", indent
);
2917 if (dllch
& IMAGE_DLLCHARACTERISTICS_WDM_DRIVER
)
2918 fprintf (file
, "%sWDM_DRIVER\n", indent
);
2919 if (dllch
& IMAGE_DLLCHARACTERISTICS_GUARD_CF
)
2920 fprintf (file
, "%sGUARD_CF\n", indent
);
2921 if (dllch
& IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE
)
2922 fprintf (file
, "%sTERMINAL_SERVICE_AWARE\n", indent
);
2924 fprintf (file
, "SizeOfStackReserve\t");
2925 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackReserve
);
2926 fprintf (file
, "\nSizeOfStackCommit\t");
2927 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackCommit
);
2928 fprintf (file
, "\nSizeOfHeapReserve\t");
2929 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapReserve
);
2930 fprintf (file
, "\nSizeOfHeapCommit\t");
2931 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapCommit
);
2932 fprintf (file
, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i
->LoaderFlags
);
2933 fprintf (file
, "NumberOfRvaAndSizes\t%08lx\n",
2934 (unsigned long) i
->NumberOfRvaAndSizes
);
2936 fprintf (file
, "\nThe Data Directory\n");
2937 for (j
= 0; j
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; j
++)
2939 fprintf (file
, "Entry %1x ", j
);
2940 bfd_fprintf_vma (abfd
, file
, i
->DataDirectory
[j
].VirtualAddress
);
2941 fprintf (file
, " %08lx ", (unsigned long) i
->DataDirectory
[j
].Size
);
2942 fprintf (file
, "%s\n", dir_names
[j
]);
2945 pe_print_idata (abfd
, vfile
);
2946 pe_print_edata (abfd
, vfile
);
2947 if (bfd_coff_have_print_pdata (abfd
))
2948 bfd_coff_print_pdata (abfd
, vfile
);
2950 pe_print_pdata (abfd
, vfile
);
2951 pe_print_reloc (abfd
, vfile
);
2952 pe_print_debugdata (abfd
, file
);
2954 rsrc_print_section (abfd
, vfile
);
2960 is_vma_in_section (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sect
, void *obj
)
2962 bfd_vma addr
= * (bfd_vma
*) obj
;
2963 return (addr
>= sect
->vma
) && (addr
< (sect
->vma
+ sect
->size
));
2967 find_section_by_vma (bfd
*abfd
, bfd_vma addr
)
2969 return bfd_sections_find_if (abfd
, is_vma_in_section
, (void *) & addr
);
2972 /* Copy any private info we understand from the input bfd
2973 to the output bfd. */
2976 _bfd_XX_bfd_copy_private_bfd_data_common (bfd
* ibfd
, bfd
* obfd
)
2978 pe_data_type
*ipe
, *ope
;
2981 /* One day we may try to grok other private data. */
2982 if (ibfd
->xvec
->flavour
!= bfd_target_coff_flavour
2983 || obfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
2986 ipe
= pe_data (ibfd
);
2987 ope
= pe_data (obfd
);
2989 /* pe_opthdr is copied in copy_object. */
2990 ope
->dll
= ipe
->dll
;
2992 /* Don't copy input subsystem if output is different from input. */
2993 if (obfd
->xvec
!= ibfd
->xvec
)
2994 ope
->pe_opthdr
.Subsystem
= IMAGE_SUBSYSTEM_UNKNOWN
;
2996 /* For strip: if we removed .reloc, we'll make a real mess of things
2997 if we don't remove this entry as well. */
2998 if (! pe_data (obfd
)->has_reloc_section
)
3000 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].VirtualAddress
= 0;
3001 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].Size
= 0;
3004 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
3005 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
3007 if (! pe_data (ibfd
)->has_reloc_section
3008 && ! (pe_data (ibfd
)->real_flags
& IMAGE_FILE_RELOCS_STRIPPED
))
3009 pe_data (obfd
)->dont_strip_reloc
= 1;
3011 memcpy (ope
->dos_message
, ipe
->dos_message
, sizeof (ope
->dos_message
));
3013 /* The file offsets contained in the debug directory need rewriting. */
3014 size
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
;
3017 bfd_vma addr
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
3018 + ope
->pe_opthdr
.ImageBase
;
3019 /* In particular a .buildid section may overlap (in VA space) with
3020 whatever section comes ahead of it (largely because of section->size
3021 representing s_size, not virt_size). Therefore don't look for the
3022 section containing the first byte, but for that covering the last
3024 bfd_vma last
= addr
+ size
- 1;
3025 asection
*section
= find_section_by_vma (obfd
, last
);
3027 if (section
!= NULL
)
3030 bfd_vma dataoff
= addr
- section
->vma
;
3032 /* PR 17512: file: 0f15796a. */
3033 if (addr
< section
->vma
3034 || section
->size
< dataoff
3035 || section
->size
- dataoff
< size
)
3037 /* xgettext:c-format */
3039 (_("%pB: Data Directory (%lx bytes at %" PRIx64
") "
3040 "extends across section boundary at %" PRIx64
),
3041 obfd
, ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
,
3042 (uint64_t) addr
, (uint64_t) section
->vma
);
3046 if ((section
->flags
& SEC_HAS_CONTENTS
) != 0
3047 && bfd_malloc_and_get_section (obfd
, section
, &data
))
3050 struct external_IMAGE_DEBUG_DIRECTORY
*dd
=
3051 (struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
);
3053 for (i
= 0; i
< ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
3054 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
3056 asection
*ddsection
;
3057 struct external_IMAGE_DEBUG_DIRECTORY
*edd
= &(dd
[i
]);
3058 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
3061 _bfd_XXi_swap_debugdir_in (obfd
, edd
, &idd
);
3063 /* RVA 0 means only offset is valid, not handled yet. */
3064 if (idd
.AddressOfRawData
== 0)
3067 idd_vma
= idd
.AddressOfRawData
+ ope
->pe_opthdr
.ImageBase
;
3068 ddsection
= find_section_by_vma (obfd
, idd_vma
);
3070 continue; /* Not in a section! */
3072 idd
.PointerToRawData
3073 = ddsection
->filepos
+ idd_vma
- ddsection
->vma
;
3074 _bfd_XXi_swap_debugdir_out (obfd
, &idd
, edd
);
3077 if (!bfd_set_section_contents (obfd
, section
, data
, 0,
3080 _bfd_error_handler (_("failed to update file offsets"
3081 " in debug directory"));
3089 _bfd_error_handler (_("%pB: failed to read "
3090 "debug data section"), obfd
);
3099 /* Copy private section data. */
3102 _bfd_XX_bfd_copy_private_section_data (bfd
*ibfd
,
3107 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
3108 || bfd_get_flavour (obfd
) != bfd_target_coff_flavour
)
3111 if (coff_section_data (ibfd
, isec
) != NULL
3112 && pei_section_data (ibfd
, isec
) != NULL
)
3114 if (coff_section_data (obfd
, osec
) == NULL
)
3116 size_t amt
= sizeof (struct coff_section_tdata
);
3117 osec
->used_by_bfd
= bfd_zalloc (obfd
, amt
);
3118 if (osec
->used_by_bfd
== NULL
)
3122 if (pei_section_data (obfd
, osec
) == NULL
)
3124 size_t amt
= sizeof (struct pei_section_tdata
);
3125 coff_section_data (obfd
, osec
)->tdata
= bfd_zalloc (obfd
, amt
);
3126 if (coff_section_data (obfd
, osec
)->tdata
== NULL
)
3130 pei_section_data (obfd
, osec
)->virt_size
=
3131 pei_section_data (ibfd
, isec
)->virt_size
;
3132 pei_section_data (obfd
, osec
)->pe_flags
=
3133 pei_section_data (ibfd
, isec
)->pe_flags
;
3140 _bfd_XX_get_symbol_info (bfd
* abfd
, asymbol
*symbol
, symbol_info
*ret
)
3142 coff_get_symbol_info (abfd
, symbol
, ret
);
3145 #if !defined(COFF_WITH_pep) && (defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64))
3147 sort_x64_pdata (const void *l
, const void *r
)
3149 const char *lp
= (const char *) l
;
3150 const char *rp
= (const char *) r
;
3152 vl
= bfd_getl32 (lp
); vr
= bfd_getl32 (rp
);
3154 return (vl
< vr
? -1 : 1);
3155 /* We compare just begin address. */
3160 /* Functions to process a .rsrc section. */
3162 static unsigned int sizeof_leaves
;
3163 static unsigned int sizeof_strings
;
3164 static unsigned int sizeof_tables_and_entries
;
3167 rsrc_count_directory (bfd
*, bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
3170 rsrc_count_entries (bfd
*abfd
,
3172 bfd_byte
*datastart
,
3177 unsigned long entry
, addr
, size
;
3179 if (data
+ 8 >= dataend
)
3186 entry
= (long) bfd_get_32 (abfd
, data
);
3188 if (HighBitSet (entry
))
3189 name
= datastart
+ WithoutHighBit (entry
);
3191 name
= datastart
+ entry
- rva_bias
;
3193 if (name
+ 2 >= dataend
|| name
< datastart
)
3196 unsigned int len
= bfd_get_16 (abfd
, name
);
3197 if (len
== 0 || len
> 256)
3201 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
3203 if (HighBitSet (entry
))
3205 data
= datastart
+ WithoutHighBit (entry
);
3207 if (data
<= datastart
|| data
>= dataend
)
3210 return rsrc_count_directory (abfd
, datastart
, data
, dataend
, rva_bias
);
3213 if (datastart
+ entry
+ 16 >= dataend
)
3216 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
);
3217 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4);
3219 return datastart
+ addr
- rva_bias
+ size
;
3223 rsrc_count_directory (bfd
* abfd
,
3224 bfd_byte
* datastart
,
3229 unsigned int num_entries
, num_ids
;
3230 bfd_byte
* highest_data
= data
;
3232 if (data
+ 16 >= dataend
)
3235 num_entries
= (int) bfd_get_16 (abfd
, data
+ 12);
3236 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14);
3238 num_entries
+= num_ids
;
3242 while (num_entries
--)
3244 bfd_byte
* entry_end
;
3246 entry_end
= rsrc_count_entries (abfd
, num_entries
>= num_ids
,
3247 datastart
, data
, dataend
, rva_bias
);
3249 highest_data
= max (highest_data
, entry_end
);
3250 if (entry_end
>= dataend
)
3254 return max (highest_data
, data
);
3257 typedef struct rsrc_dir_chain
3259 unsigned int num_entries
;
3260 struct rsrc_entry
* first_entry
;
3261 struct rsrc_entry
* last_entry
;
3264 typedef struct rsrc_directory
3266 unsigned int characteristics
;
3271 rsrc_dir_chain names
;
3274 struct rsrc_entry
* entry
;
3277 typedef struct rsrc_string
3283 typedef struct rsrc_leaf
3286 unsigned int codepage
;
3290 typedef struct rsrc_entry
3296 struct rsrc_string name
;
3302 struct rsrc_directory
* directory
;
3303 struct rsrc_leaf
* leaf
;
3306 struct rsrc_entry
* next_entry
;
3307 struct rsrc_directory
* parent
;
3311 rsrc_parse_directory (bfd
*, rsrc_directory
*, bfd_byte
*,
3312 bfd_byte
*, bfd_byte
*, bfd_vma
, rsrc_entry
*);
3315 rsrc_parse_entry (bfd
*abfd
,
3318 bfd_byte
*datastart
,
3322 rsrc_directory
*parent
)
3324 unsigned long val
, addr
, size
;
3326 val
= bfd_get_32 (abfd
, data
);
3328 entry
->parent
= parent
;
3329 entry
->is_name
= is_name
;
3335 if (HighBitSet (val
))
3337 val
= WithoutHighBit (val
);
3339 address
= datastart
+ val
;
3343 address
= datastart
+ val
- rva_bias
;
3346 if (address
+ 3 > dataend
)
3349 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, address
);
3350 entry
->name_id
.name
.string
= address
+ 2;
3353 entry
->name_id
.id
= val
;
3355 val
= bfd_get_32 (abfd
, data
+ 4);
3357 if (HighBitSet (val
))
3359 entry
->is_dir
= true;
3360 entry
->value
.directory
= bfd_malloc (sizeof (*entry
->value
.directory
));
3361 if (entry
->value
.directory
== NULL
)
3364 return rsrc_parse_directory (abfd
, entry
->value
.directory
,
3366 datastart
+ WithoutHighBit (val
),
3367 dataend
, rva_bias
, entry
);
3370 entry
->is_dir
= false;
3371 entry
->value
.leaf
= bfd_malloc (sizeof (*entry
->value
.leaf
));
3372 if (entry
->value
.leaf
== NULL
)
3375 data
= datastart
+ val
;
3376 if (data
< datastart
|| data
+ 12 > dataend
)
3379 addr
= bfd_get_32 (abfd
, data
);
3380 size
= entry
->value
.leaf
->size
= bfd_get_32 (abfd
, data
+ 4);
3381 entry
->value
.leaf
->codepage
= bfd_get_32 (abfd
, data
+ 8);
3382 /* FIXME: We assume that the reserved field (data + 12) is OK. */
3384 if (size
> dataend
- datastart
- (addr
- rva_bias
))
3386 entry
->value
.leaf
->data
= bfd_malloc (size
);
3387 if (entry
->value
.leaf
->data
== NULL
)
3390 memcpy (entry
->value
.leaf
->data
, datastart
+ addr
- rva_bias
, size
);
3391 return datastart
+ (addr
- rva_bias
) + size
;
3395 rsrc_parse_entries (bfd
*abfd
,
3396 rsrc_dir_chain
*chain
,
3398 bfd_byte
*highest_data
,
3399 bfd_byte
*datastart
,
3403 rsrc_directory
*parent
)
3408 if (chain
->num_entries
== 0)
3410 chain
->first_entry
= chain
->last_entry
= NULL
;
3411 return highest_data
;
3414 entry
= bfd_malloc (sizeof (*entry
));
3418 chain
->first_entry
= entry
;
3420 for (i
= chain
->num_entries
; i
--;)
3422 bfd_byte
* entry_end
;
3424 entry_end
= rsrc_parse_entry (abfd
, is_name
, entry
, datastart
,
3425 data
, dataend
, rva_bias
, parent
);
3427 highest_data
= max (entry_end
, highest_data
);
3428 if (entry_end
> dataend
)
3433 entry
->next_entry
= bfd_malloc (sizeof (*entry
));
3434 entry
= entry
->next_entry
;
3439 entry
->next_entry
= NULL
;
3442 chain
->last_entry
= entry
;
3444 return highest_data
;
3448 rsrc_parse_directory (bfd
* abfd
,
3449 rsrc_directory
* table
,
3450 bfd_byte
* datastart
,
3456 bfd_byte
* highest_data
= data
;
3461 table
->characteristics
= bfd_get_32 (abfd
, data
);
3462 table
->time
= bfd_get_32 (abfd
, data
+ 4);
3463 table
->major
= bfd_get_16 (abfd
, data
+ 8);
3464 table
->minor
= bfd_get_16 (abfd
, data
+ 10);
3465 table
->names
.num_entries
= bfd_get_16 (abfd
, data
+ 12);
3466 table
->ids
.num_entries
= bfd_get_16 (abfd
, data
+ 14);
3467 table
->entry
= entry
;
3471 highest_data
= rsrc_parse_entries (abfd
, & table
->names
, true, data
,
3472 datastart
, data
, dataend
, rva_bias
, table
);
3473 data
+= table
->names
.num_entries
* 8;
3475 highest_data
= rsrc_parse_entries (abfd
, & table
->ids
, false, highest_data
,
3476 datastart
, data
, dataend
, rva_bias
, table
);
3477 data
+= table
->ids
.num_entries
* 8;
3479 return max (highest_data
, data
);
3482 typedef struct rsrc_write_data
3485 bfd_byte
* datastart
;
3486 bfd_byte
* next_table
;
3487 bfd_byte
* next_leaf
;
3488 bfd_byte
* next_string
;
3489 bfd_byte
* next_data
;
3494 rsrc_write_string (rsrc_write_data
* data
,
3495 rsrc_string
* string
)
3497 bfd_put_16 (data
->abfd
, string
->len
, data
->next_string
);
3498 memcpy (data
->next_string
+ 2, string
->string
, string
->len
* 2);
3499 data
->next_string
+= (string
->len
+ 1) * 2;
3502 static inline unsigned int
3503 rsrc_compute_rva (rsrc_write_data
* data
,
3506 return (addr
- data
->datastart
) + data
->rva_bias
;
3510 rsrc_write_leaf (rsrc_write_data
* data
,
3513 bfd_put_32 (data
->abfd
, rsrc_compute_rva (data
, data
->next_data
),
3515 bfd_put_32 (data
->abfd
, leaf
->size
, data
->next_leaf
+ 4);
3516 bfd_put_32 (data
->abfd
, leaf
->codepage
, data
->next_leaf
+ 8);
3517 bfd_put_32 (data
->abfd
, 0 /*reserved*/, data
->next_leaf
+ 12);
3518 data
->next_leaf
+= 16;
3520 memcpy (data
->next_data
, leaf
->data
, leaf
->size
);
3521 /* An undocumented feature of Windows resources is that each unit
3522 of raw data is 8-byte aligned... */
3523 data
->next_data
+= ((leaf
->size
+ 7) & ~7);
3526 static void rsrc_write_directory (rsrc_write_data
*, rsrc_directory
*);
3529 rsrc_write_entry (rsrc_write_data
* data
,
3535 bfd_put_32 (data
->abfd
,
3536 SetHighBit (data
->next_string
- data
->datastart
),
3538 rsrc_write_string (data
, & entry
->name_id
.name
);
3541 bfd_put_32 (data
->abfd
, entry
->name_id
.id
, where
);
3545 bfd_put_32 (data
->abfd
,
3546 SetHighBit (data
->next_table
- data
->datastart
),
3548 rsrc_write_directory (data
, entry
->value
.directory
);
3552 bfd_put_32 (data
->abfd
, data
->next_leaf
- data
->datastart
, where
+ 4);
3553 rsrc_write_leaf (data
, entry
->value
.leaf
);
3558 rsrc_compute_region_sizes (rsrc_directory
* dir
)
3560 struct rsrc_entry
* entry
;
3565 sizeof_tables_and_entries
+= 16;
3567 for (entry
= dir
->names
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3569 sizeof_tables_and_entries
+= 8;
3571 sizeof_strings
+= (entry
->name_id
.name
.len
+ 1) * 2;
3574 rsrc_compute_region_sizes (entry
->value
.directory
);
3576 sizeof_leaves
+= 16;
3579 for (entry
= dir
->ids
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3581 sizeof_tables_and_entries
+= 8;
3584 rsrc_compute_region_sizes (entry
->value
.directory
);
3586 sizeof_leaves
+= 16;
3591 rsrc_write_directory (rsrc_write_data
* data
,
3592 rsrc_directory
* dir
)
3596 bfd_byte
* next_entry
;
3599 bfd_put_32 (data
->abfd
, dir
->characteristics
, data
->next_table
);
3600 bfd_put_32 (data
->abfd
, 0 /*dir->time*/, data
->next_table
+ 4);
3601 bfd_put_16 (data
->abfd
, dir
->major
, data
->next_table
+ 8);
3602 bfd_put_16 (data
->abfd
, dir
->minor
, data
->next_table
+ 10);
3603 bfd_put_16 (data
->abfd
, dir
->names
.num_entries
, data
->next_table
+ 12);
3604 bfd_put_16 (data
->abfd
, dir
->ids
.num_entries
, data
->next_table
+ 14);
3606 /* Compute where the entries and the next table will be placed. */
3607 next_entry
= data
->next_table
+ 16;
3608 data
->next_table
= next_entry
+ (dir
->names
.num_entries
* 8)
3609 + (dir
->ids
.num_entries
* 8);
3610 nt
= data
->next_table
;
3612 /* Write the entries. */
3613 for (i
= dir
->names
.num_entries
, entry
= dir
->names
.first_entry
;
3614 i
> 0 && entry
!= NULL
;
3615 i
--, entry
= entry
->next_entry
)
3617 BFD_ASSERT (entry
->is_name
);
3618 rsrc_write_entry (data
, next_entry
, entry
);
3621 BFD_ASSERT (i
== 0);
3622 BFD_ASSERT (entry
== NULL
);
3624 for (i
= dir
->ids
.num_entries
, entry
= dir
->ids
.first_entry
;
3625 i
> 0 && entry
!= NULL
;
3626 i
--, entry
= entry
->next_entry
)
3628 BFD_ASSERT (! entry
->is_name
);
3629 rsrc_write_entry (data
, next_entry
, entry
);
3632 BFD_ASSERT (i
== 0);
3633 BFD_ASSERT (entry
== NULL
);
3634 BFD_ASSERT (nt
== next_entry
);
3637 #if ! defined __CYGWIN__ && ! defined __MINGW32__
3638 /* Return the length (number of units) of the first character in S,
3639 putting its 'ucs4_t' representation in *PUC. */
3642 u16_mbtouc (wint_t * puc
, const unsigned short * s
, unsigned int n
)
3644 unsigned short c
= * s
;
3646 if (c
< 0xd800 || c
>= 0xe000)
3656 if (s
[1] >= 0xdc00 && s
[1] < 0xe000)
3658 *puc
= 0x10000 + ((c
- 0xd800) << 10) + (s
[1] - 0xdc00);
3664 /* Incomplete multibyte character. */
3670 /* Invalid multibyte character. */
3674 #endif /* not Cygwin/Mingw */
3676 /* Perform a comparison of two entries. */
3678 rsrc_cmp (bool is_name
, rsrc_entry
* a
, rsrc_entry
* b
)
3687 return a
->name_id
.id
- b
->name_id
.id
;
3689 /* We have to perform a case insenstive, unicode string comparison... */
3690 astring
= a
->name_id
.name
.string
;
3691 alen
= a
->name_id
.name
.len
;
3692 bstring
= b
->name_id
.name
.string
;
3693 blen
= b
->name_id
.name
.len
;
3695 #if defined __CYGWIN__ || defined __MINGW32__
3696 /* Under Windows hosts (both Cygwin and Mingw types),
3697 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3698 function however goes by different names in the two environments... */
3702 #define rscpcmp wcsncasecmp
3705 #define rscpcmp wcsnicmp
3708 res
= rscpcmp ((const wchar_t *) astring
, (const wchar_t *) bstring
,
3716 for (i
= min (alen
, blen
); i
--; astring
+= 2, bstring
+= 2)
3721 /* Convert UTF-16 unicode characters into wchar_t characters
3722 so that we can then perform a case insensitive comparison. */
3723 unsigned int Alen
= u16_mbtouc (& awc
, (const unsigned short *) astring
, 2);
3724 unsigned int Blen
= u16_mbtouc (& bwc
, (const unsigned short *) bstring
, 2);
3729 awc
= towlower (awc
);
3730 bwc
= towlower (bwc
);
3746 rsrc_print_name (char * buffer
, rsrc_string string
)
3749 bfd_byte
* name
= string
.string
;
3751 for (i
= string
.len
; i
--; name
+= 2)
3752 sprintf (buffer
+ strlen (buffer
), "%.1s", name
);
3756 rsrc_resource_name (rsrc_entry
*entry
, rsrc_directory
*dir
, char *buffer
)
3758 bool is_string
= false;
3762 if (dir
!= NULL
&& dir
->entry
!= NULL
&& dir
->entry
->parent
!= NULL
3763 && dir
->entry
->parent
->entry
!= NULL
)
3765 strcpy (buffer
, "type: ");
3766 if (dir
->entry
->parent
->entry
->is_name
)
3767 rsrc_print_name (buffer
+ strlen (buffer
),
3768 dir
->entry
->parent
->entry
->name_id
.name
);
3771 unsigned int id
= dir
->entry
->parent
->entry
->name_id
.id
;
3773 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3776 case 1: strcat (buffer
, " (CURSOR)"); break;
3777 case 2: strcat (buffer
, " (BITMAP)"); break;
3778 case 3: strcat (buffer
, " (ICON)"); break;
3779 case 4: strcat (buffer
, " (MENU)"); break;
3780 case 5: strcat (buffer
, " (DIALOG)"); break;
3781 case 6: strcat (buffer
, " (STRING)"); is_string
= true; break;
3782 case 7: strcat (buffer
, " (FONTDIR)"); break;
3783 case 8: strcat (buffer
, " (FONT)"); break;
3784 case 9: strcat (buffer
, " (ACCELERATOR)"); break;
3785 case 10: strcat (buffer
, " (RCDATA)"); break;
3786 case 11: strcat (buffer
, " (MESSAGETABLE)"); break;
3787 case 12: strcat (buffer
, " (GROUP_CURSOR)"); break;
3788 case 14: strcat (buffer
, " (GROUP_ICON)"); break;
3789 case 16: strcat (buffer
, " (VERSION)"); break;
3790 case 17: strcat (buffer
, " (DLGINCLUDE)"); break;
3791 case 19: strcat (buffer
, " (PLUGPLAY)"); break;
3792 case 20: strcat (buffer
, " (VXD)"); break;
3793 case 21: strcat (buffer
, " (ANICURSOR)"); break;
3794 case 22: strcat (buffer
, " (ANIICON)"); break;
3795 case 23: strcat (buffer
, " (HTML)"); break;
3796 case 24: strcat (buffer
, " (MANIFEST)"); break;
3797 case 240: strcat (buffer
, " (DLGINIT)"); break;
3798 case 241: strcat (buffer
, " (TOOLBAR)"); break;
3803 if (dir
!= NULL
&& dir
->entry
!= NULL
)
3805 strcat (buffer
, " name: ");
3806 if (dir
->entry
->is_name
)
3807 rsrc_print_name (buffer
+ strlen (buffer
), dir
->entry
->name_id
.name
);
3810 unsigned int id
= dir
->entry
->name_id
.id
;
3812 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3815 sprintf (buffer
+ strlen (buffer
), " (resource id range: %d - %d)",
3816 (id
- 1) << 4, (id
<< 4) - 1);
3822 strcat (buffer
, " lang: ");
3825 rsrc_print_name (buffer
+ strlen (buffer
), entry
->name_id
.name
);
3827 sprintf (buffer
+ strlen (buffer
), "%x", entry
->name_id
.id
);
3833 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3834 their ID is stored in the NAME entry. The bottom four bits are used as
3835 an index into unicode string table that makes up the data of the leaf.
3836 So identical type-name-lang string resources may not actually be
3839 This function is called when we have detected two string resources with
3840 match top-28-bit IDs. We have to scan the string tables inside the leaves
3841 and discover if there are any real collisions. If there are then we report
3842 them and return FALSE. Otherwise we copy any strings from B into A and
3843 then return TRUE. */
3846 rsrc_merge_string_entries (rsrc_entry
* a ATTRIBUTE_UNUSED
,
3847 rsrc_entry
* b ATTRIBUTE_UNUSED
)
3849 unsigned int copy_needed
= 0;
3853 bfd_byte
* new_data
;
3856 /* Step one: Find out what we have to do. */
3857 BFD_ASSERT (! a
->is_dir
);
3858 astring
= a
->value
.leaf
->data
;
3860 BFD_ASSERT (! b
->is_dir
);
3861 bstring
= b
->value
.leaf
->data
;
3863 for (i
= 0; i
< 16; i
++)
3865 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3866 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3870 copy_needed
+= blen
* 2;
3874 else if (alen
!= blen
)
3875 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3877 /* alen == blen != 0. We might have two identical strings. If so we
3878 can ignore the second one. There is no need for wchar_t vs UTF-16
3879 theatrics here - we are only interested in (case sensitive) equality. */
3880 else if (memcmp (astring
+ 2, bstring
+ 2, alen
* 2) != 0)
3883 astring
+= (alen
+ 1) * 2;
3884 bstring
+= (blen
+ 1) * 2;
3889 if (a
->parent
!= NULL
3890 && a
->parent
->entry
!= NULL
3891 && !a
->parent
->entry
->is_name
)
3892 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3893 ((a
->parent
->entry
->name_id
.id
- 1) << 4) + i
);
3897 if (copy_needed
== 0)
3900 /* If we reach here then A and B must both have non-colliding strings.
3901 (We never get string resources with fully empty string tables).
3902 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3904 new_data
= bfd_malloc (a
->value
.leaf
->size
+ copy_needed
);
3905 if (new_data
== NULL
)
3909 astring
= a
->value
.leaf
->data
;
3910 bstring
= b
->value
.leaf
->data
;
3912 for (i
= 0; i
< 16; i
++)
3914 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3915 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3919 memcpy (nstring
, astring
, (alen
+ 1) * 2);
3920 nstring
+= (alen
+ 1) * 2;
3924 memcpy (nstring
, bstring
, (blen
+ 1) * 2);
3925 nstring
+= (blen
+ 1) * 2;
3933 astring
+= (alen
+ 1) * 2;
3934 bstring
+= (blen
+ 1) * 2;
3937 BFD_ASSERT (nstring
- new_data
== (signed) (a
->value
.leaf
->size
+ copy_needed
));
3939 free (a
->value
.leaf
->data
);
3940 a
->value
.leaf
->data
= new_data
;
3941 a
->value
.leaf
->size
+= copy_needed
;
3946 static void rsrc_merge (rsrc_entry
*, rsrc_entry
*);
3948 /* Sort the entries in given part of the directory.
3949 We use an old fashioned bubble sort because we are dealing
3950 with lists and we want to handle matches specially. */
3953 rsrc_sort_entries (rsrc_dir_chain
*chain
,
3955 rsrc_directory
*dir
)
3959 rsrc_entry
** points_to_entry
;
3962 if (chain
->num_entries
< 2)
3968 points_to_entry
= & chain
->first_entry
;
3969 entry
= * points_to_entry
;
3970 next
= entry
->next_entry
;
3974 signed int cmp
= rsrc_cmp (is_name
, entry
, next
);
3978 entry
->next_entry
= next
->next_entry
;
3979 next
->next_entry
= entry
;
3980 * points_to_entry
= next
;
3981 points_to_entry
= & next
->next_entry
;
3982 next
= entry
->next_entry
;
3987 if (entry
->is_dir
&& next
->is_dir
)
3989 /* When we encounter identical directory entries we have to
3990 merge them together. The exception to this rule is for
3991 resource manifests - there can only be one of these,
3992 even if they differ in language. Zero-language manifests
3993 are assumed to be default manifests (provided by the
3994 Cygwin/MinGW build system) and these can be silently dropped,
3995 unless that would reduce the number of manifests to zero.
3996 There should only ever be one non-zero lang manifest -
3997 if there are more it is an error. A non-zero lang
3998 manifest takes precedence over a default manifest. */
4000 && entry
->name_id
.id
== 1
4002 && dir
->entry
!= NULL
4003 && !dir
->entry
->is_name
4004 && dir
->entry
->name_id
.id
== 0x18)
4006 if (next
->value
.directory
->names
.num_entries
== 0
4007 && next
->value
.directory
->ids
.num_entries
== 1
4008 && !next
->value
.directory
->ids
.first_entry
->is_name
4009 && next
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
4010 /* Fall through so that NEXT is dropped. */
4012 else if (entry
->value
.directory
->names
.num_entries
== 0
4013 && entry
->value
.directory
->ids
.num_entries
== 1
4014 && !entry
->value
.directory
->ids
.first_entry
->is_name
4015 && entry
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
4017 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
4018 entry
->next_entry
= next
->next_entry
;
4019 next
->next_entry
= entry
;
4020 * points_to_entry
= next
;
4021 points_to_entry
= & next
->next_entry
;
4022 next
= entry
->next_entry
;
4027 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
4028 bfd_set_error (bfd_error_file_truncated
);
4032 /* Unhook NEXT from the chain. */
4033 /* FIXME: memory loss here. */
4034 entry
->next_entry
= next
->next_entry
;
4035 chain
->num_entries
--;
4036 if (chain
->num_entries
< 2)
4038 next
= next
->next_entry
;
4041 rsrc_merge (entry
, next
);
4043 else if (entry
->is_dir
!= next
->is_dir
)
4045 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
4046 bfd_set_error (bfd_error_file_truncated
);
4051 /* Otherwise with identical leaves we issue an error
4052 message - because there should never be duplicates.
4053 The exception is Type 18/Name 1/Lang 0 which is the
4054 defaul manifest - this can just be dropped. */
4056 && entry
->name_id
.id
== 0
4058 && dir
->entry
!= NULL
4059 && !dir
->entry
->is_name
4060 && dir
->entry
->name_id
.id
== 1
4061 && dir
->entry
->parent
!= NULL
4062 && dir
->entry
->parent
->entry
!= NULL
4063 && !dir
->entry
->parent
->entry
->is_name
4064 && dir
->entry
->parent
->entry
->name_id
.id
== 0x18 /* RT_MANIFEST */)
4066 else if (dir
!= NULL
4067 && dir
->entry
!= NULL
4068 && dir
->entry
->parent
!= NULL
4069 && dir
->entry
->parent
->entry
!= NULL
4070 && !dir
->entry
->parent
->entry
->is_name
4071 && dir
->entry
->parent
->entry
->name_id
.id
== 0x6 /* RT_STRING */)
4073 /* Strings need special handling. */
4074 if (! rsrc_merge_string_entries (entry
, next
))
4076 /* _bfd_error_handler should have been called inside merge_strings. */
4077 bfd_set_error (bfd_error_file_truncated
);
4084 || dir
->entry
== NULL
4085 || dir
->entry
->parent
== NULL
4086 || dir
->entry
->parent
->entry
== NULL
)
4087 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
4092 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
4093 rsrc_resource_name (entry
, dir
, buff
));
4095 bfd_set_error (bfd_error_file_truncated
);
4100 /* Unhook NEXT from the chain. */
4101 entry
->next_entry
= next
->next_entry
;
4102 chain
->num_entries
--;
4103 if (chain
->num_entries
< 2)
4105 next
= next
->next_entry
;
4109 points_to_entry
= & entry
->next_entry
;
4111 next
= next
->next_entry
;
4116 chain
->last_entry
= entry
;
4121 /* Attach B's chain onto A. */
4123 rsrc_attach_chain (rsrc_dir_chain
* achain
, rsrc_dir_chain
* bchain
)
4125 if (bchain
->num_entries
== 0)
4128 achain
->num_entries
+= bchain
->num_entries
;
4130 if (achain
->first_entry
== NULL
)
4132 achain
->first_entry
= bchain
->first_entry
;
4133 achain
->last_entry
= bchain
->last_entry
;
4137 achain
->last_entry
->next_entry
= bchain
->first_entry
;
4138 achain
->last_entry
= bchain
->last_entry
;
4141 bchain
->num_entries
= 0;
4142 bchain
->first_entry
= bchain
->last_entry
= NULL
;
4146 rsrc_merge (struct rsrc_entry
* a
, struct rsrc_entry
* b
)
4148 rsrc_directory
* adir
;
4149 rsrc_directory
* bdir
;
4151 BFD_ASSERT (a
->is_dir
);
4152 BFD_ASSERT (b
->is_dir
);
4154 adir
= a
->value
.directory
;
4155 bdir
= b
->value
.directory
;
4157 if (adir
->characteristics
!= bdir
->characteristics
)
4159 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics"));
4160 bfd_set_error (bfd_error_file_truncated
);
4164 if (adir
->major
!= bdir
->major
|| adir
->minor
!= bdir
->minor
)
4166 _bfd_error_handler (_(".rsrc merge failure: differing directory versions"));
4167 bfd_set_error (bfd_error_file_truncated
);
4171 /* Attach B's name chain to A. */
4172 rsrc_attach_chain (& adir
->names
, & bdir
->names
);
4174 /* Attach B's ID chain to A. */
4175 rsrc_attach_chain (& adir
->ids
, & bdir
->ids
);
4177 /* Now sort A's entries. */
4178 rsrc_sort_entries (& adir
->names
, true, adir
);
4179 rsrc_sort_entries (& adir
->ids
, false, adir
);
4182 /* Check the .rsrc section. If it contains multiple concatenated
4183 resources then we must merge them properly. Otherwise Windows
4184 will ignore all but the first set. */
4187 rsrc_process_section (bfd
* abfd
,
4188 struct coff_final_link_info
* pfinfo
)
4190 rsrc_directory new_table
;
4196 bfd_byte
* datastart
;
4198 bfd_byte
* new_data
;
4199 unsigned int num_resource_sets
;
4200 rsrc_directory
* type_tables
;
4201 rsrc_write_data write_data
;
4204 unsigned int num_input_rsrc
= 0;
4205 unsigned int max_num_input_rsrc
= 4;
4206 ptrdiff_t * rsrc_sizes
= NULL
;
4208 new_table
.names
.num_entries
= 0;
4209 new_table
.ids
.num_entries
= 0;
4211 sec
= bfd_get_section_by_name (abfd
, ".rsrc");
4212 if (sec
== NULL
|| (size
= sec
->rawsize
) == 0)
4215 pe
= pe_data (abfd
);
4219 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4221 if (! bfd_malloc_and_get_section (abfd
, sec
, &datastart
))
4224 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4225 their lengths. Note - we rely upon the fact that the linker script
4226 does *not* sort the input .rsrc sections, so that the order in the
4227 linkinfo list matches the order in the output .rsrc section.
4229 We need to know the lengths because each input .rsrc section has padding
4230 at the end of a variable amount. (It does not appear to be based upon
4231 the section alignment or the file alignment). We need to skip any
4232 padding bytes when parsing the input .rsrc sections. */
4234 rsrc_sizes
= bfd_malloc (max_num_input_rsrc
* sizeof (*rsrc_sizes
));
4235 if (rsrc_sizes
== NULL
)
4238 for (input
= pfinfo
->info
->input_bfds
;
4240 input
= input
->link
.next
)
4242 asection
* rsrc_sec
= bfd_get_section_by_name (input
, ".rsrc");
4244 /* PR 18372 - skip discarded .rsrc sections. */
4245 if (rsrc_sec
!= NULL
&& !discarded_section (rsrc_sec
))
4247 if (num_input_rsrc
== max_num_input_rsrc
)
4249 max_num_input_rsrc
+= 10;
4250 rsrc_sizes
= bfd_realloc (rsrc_sizes
, max_num_input_rsrc
4251 * sizeof (*rsrc_sizes
));
4252 if (rsrc_sizes
== NULL
)
4256 BFD_ASSERT (rsrc_sec
->size
> 0);
4257 rsrc_sizes
[num_input_rsrc
++] = rsrc_sec
->size
;
4261 if (num_input_rsrc
< 2)
4264 /* Step one: Walk the section, computing the size of the tables,
4265 leaves and data and decide if we need to do anything. */
4266 dataend
= data
+ size
;
4267 num_resource_sets
= 0;
4269 while (data
< dataend
)
4271 bfd_byte
* p
= data
;
4273 data
= rsrc_count_directory (abfd
, data
, data
, dataend
, rva_bias
);
4277 /* Corrupted .rsrc section - cannot merge. */
4278 _bfd_error_handler (_("%pB: .rsrc merge failure: corrupt .rsrc section"),
4280 bfd_set_error (bfd_error_file_truncated
);
4284 if ((data
- p
) > rsrc_sizes
[num_resource_sets
])
4286 _bfd_error_handler (_("%pB: .rsrc merge failure: unexpected .rsrc size"),
4288 bfd_set_error (bfd_error_file_truncated
);
4291 /* FIXME: Should we add a check for "data - p" being much smaller
4292 than rsrc_sizes[num_resource_sets] ? */
4294 data
= p
+ rsrc_sizes
[num_resource_sets
];
4295 rva_bias
+= data
- p
;
4296 ++ num_resource_sets
;
4298 BFD_ASSERT (num_resource_sets
== num_input_rsrc
);
4300 /* Step two: Walk the data again, building trees of the resources. */
4302 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4304 type_tables
= bfd_malloc (num_resource_sets
* sizeof (*type_tables
));
4305 if (type_tables
== NULL
)
4309 while (data
< dataend
)
4311 bfd_byte
* p
= data
;
4313 (void) rsrc_parse_directory (abfd
, type_tables
+ indx
, data
, data
,
4314 dataend
, rva_bias
, NULL
);
4315 data
= p
+ rsrc_sizes
[indx
];
4316 rva_bias
+= data
- p
;
4319 BFD_ASSERT (indx
== num_resource_sets
);
4321 /* Step three: Merge the top level tables (there can be only one).
4323 We must ensure that the merged entries are in ascending order.
4325 We also thread the top level table entries from the old tree onto
4326 the new table, so that they can be pulled off later. */
4328 /* FIXME: Should we verify that all type tables are the same ? */
4329 new_table
.characteristics
= type_tables
[0].characteristics
;
4330 new_table
.time
= type_tables
[0].time
;
4331 new_table
.major
= type_tables
[0].major
;
4332 new_table
.minor
= type_tables
[0].minor
;
4334 /* Chain the NAME entries onto the table. */
4335 new_table
.names
.first_entry
= NULL
;
4336 new_table
.names
.last_entry
= NULL
;
4338 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4339 rsrc_attach_chain (& new_table
.names
, & type_tables
[indx
].names
);
4341 rsrc_sort_entries (& new_table
.names
, true, & new_table
);
4343 /* Chain the ID entries onto the table. */
4344 new_table
.ids
.first_entry
= NULL
;
4345 new_table
.ids
.last_entry
= NULL
;
4347 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4348 rsrc_attach_chain (& new_table
.ids
, & type_tables
[indx
].ids
);
4350 rsrc_sort_entries (& new_table
.ids
, false, & new_table
);
4352 /* Step four: Create new contents for the .rsrc section. */
4353 /* Step four point one: Compute the size of each region of the .rsrc section.
4354 We do this now, rather than earlier, as the merging above may have dropped
4356 sizeof_leaves
= sizeof_strings
= sizeof_tables_and_entries
= 0;
4357 rsrc_compute_region_sizes (& new_table
);
4358 /* We increment sizeof_strings to make sure that resource data
4359 starts on an 8-byte boundary. FIXME: Is this correct ? */
4360 sizeof_strings
= (sizeof_strings
+ 7) & ~ 7;
4362 new_data
= bfd_zalloc (abfd
, size
);
4363 if (new_data
== NULL
)
4366 write_data
.abfd
= abfd
;
4367 write_data
.datastart
= new_data
;
4368 write_data
.next_table
= new_data
;
4369 write_data
.next_leaf
= new_data
+ sizeof_tables_and_entries
;
4370 write_data
.next_string
= write_data
.next_leaf
+ sizeof_leaves
;
4371 write_data
.next_data
= write_data
.next_string
+ sizeof_strings
;
4372 write_data
.rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4374 rsrc_write_directory (& write_data
, & new_table
);
4376 /* Step five: Replace the old contents with the new.
4377 We don't recompute the size as it's too late here to shrink section.
4378 See PR ld/20193 for more details. */
4379 bfd_set_section_contents (pfinfo
->output_bfd
, sec
, new_data
, 0, size
);
4380 sec
->size
= sec
->rawsize
= size
;
4383 /* Step six: Free all the memory that we have used. */
4384 /* FIXME: Free the resource tree, if we have one. */
4389 /* Handle the .idata section and other things that need symbol table
4393 _bfd_XXi_final_link_postscript (bfd
* abfd
, struct coff_final_link_info
*pfinfo
)
4395 struct coff_link_hash_entry
*h1
;
4396 struct bfd_link_info
*info
= pfinfo
->info
;
4399 /* There are a few fields that need to be filled in now while we
4400 have symbol table access.
4402 The .idata subsections aren't directly available as sections, but
4403 they are in the symbol table, so get them from there. */
4405 /* The import directory. This is the address of .idata$2, with size
4406 of .idata$2 + .idata$3. */
4407 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4408 ".idata$2", false, false, true);
4411 /* PR ld/2729: We cannot rely upon all the output sections having been
4412 created properly, so check before referencing them. Issue a warning
4413 message for any sections tht could not be found. */
4414 if ((h1
->root
.type
== bfd_link_hash_defined
4415 || h1
->root
.type
== bfd_link_hash_defweak
)
4416 && h1
->root
.u
.def
.section
!= NULL
4417 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4418 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
=
4419 (h1
->root
.u
.def
.value
4420 + h1
->root
.u
.def
.section
->output_section
->vma
4421 + h1
->root
.u
.def
.section
->output_offset
);
4425 (_("%pB: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4430 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4431 ".idata$4", false, false, true);
4433 && (h1
->root
.type
== bfd_link_hash_defined
4434 || h1
->root
.type
== bfd_link_hash_defweak
)
4435 && h1
->root
.u
.def
.section
!= NULL
4436 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4437 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].Size
=
4438 ((h1
->root
.u
.def
.value
4439 + h1
->root
.u
.def
.section
->output_section
->vma
4440 + h1
->root
.u
.def
.section
->output_offset
)
4441 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
);
4445 (_("%pB: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4450 /* The import address table. This is the size/address of
4452 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4453 ".idata$5", false, false, true);
4455 && (h1
->root
.type
== bfd_link_hash_defined
4456 || h1
->root
.type
== bfd_link_hash_defweak
)
4457 && h1
->root
.u
.def
.section
!= NULL
4458 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4459 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4460 (h1
->root
.u
.def
.value
4461 + h1
->root
.u
.def
.section
->output_section
->vma
4462 + h1
->root
.u
.def
.section
->output_offset
);
4466 (_("%pB: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4471 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4472 ".idata$6", false, false, true);
4474 && (h1
->root
.type
== bfd_link_hash_defined
4475 || h1
->root
.type
== bfd_link_hash_defweak
)
4476 && h1
->root
.u
.def
.section
!= NULL
4477 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4478 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4479 ((h1
->root
.u
.def
.value
4480 + h1
->root
.u
.def
.section
->output_section
->vma
4481 + h1
->root
.u
.def
.section
->output_offset
)
4482 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
);
4486 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4493 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4494 "__IAT_start__", false, false, true);
4496 && (h1
->root
.type
== bfd_link_hash_defined
4497 || h1
->root
.type
== bfd_link_hash_defweak
)
4498 && h1
->root
.u
.def
.section
!= NULL
4499 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4504 (h1
->root
.u
.def
.value
4505 + h1
->root
.u
.def
.section
->output_section
->vma
4506 + h1
->root
.u
.def
.section
->output_offset
);
4508 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4509 "__IAT_end__", false, false, true);
4511 && (h1
->root
.type
== bfd_link_hash_defined
4512 || h1
->root
.type
== bfd_link_hash_defweak
)
4513 && h1
->root
.u
.def
.section
!= NULL
4514 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4516 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4517 ((h1
->root
.u
.def
.value
4518 + h1
->root
.u
.def
.section
->output_section
->vma
4519 + h1
->root
.u
.def
.section
->output_offset
)
4521 if (pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
!= 0)
4522 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4523 iat_va
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
4528 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4529 " because .idata$6 is missing"), abfd
);
4535 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4536 (bfd_get_symbol_leading_char (abfd
) != 0
4537 ? "__tls_used" : "_tls_used"),
4538 false, false, true);
4541 if ((h1
->root
.type
== bfd_link_hash_defined
4542 || h1
->root
.type
== bfd_link_hash_defweak
)
4543 && h1
->root
.u
.def
.section
!= NULL
4544 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4545 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].VirtualAddress
=
4546 (h1
->root
.u
.def
.value
4547 + h1
->root
.u
.def
.section
->output_section
->vma
4548 + h1
->root
.u
.def
.section
->output_offset
4549 - pe_data (abfd
)->pe_opthdr
.ImageBase
);
4553 (_("%pB: unable to fill in DataDictionary[9] because __tls_used is missing"),
4557 /* According to PECOFF sepcifications by Microsoft version 8.2
4558 the TLS data directory consists of 4 pointers, followed
4559 by two 4-byte integer. This implies that the total size
4560 is different for 32-bit and 64-bit executables. */
4561 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
4562 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x18;
4564 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x28;
4568 /* If there is a .pdata section and we have linked pdata finally, we
4569 need to sort the entries ascending. */
4570 #if !defined(COFF_WITH_pep) && (defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64))
4572 asection
*sec
= bfd_get_section_by_name (abfd
, ".pdata");
4576 bfd_size_type x
= sec
->rawsize
;
4579 if (bfd_malloc_and_get_section (abfd
, sec
, &tmp_data
))
4583 12, sort_x64_pdata
);
4584 bfd_set_section_contents (pfinfo
->output_bfd
, sec
,
4594 rsrc_process_section (abfd
, pfinfo
);
4596 /* If we couldn't find idata$2, we either have an excessively
4597 trivial program or are in DEEP trouble; we have to assume trivial