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)
841 H_PUT_32 (abfd
, time (0), filehdr_out
->f_timdat
);
843 H_PUT_32 (abfd
, pe_data (abfd
)->timestamp
, filehdr_out
->f_timdat
);
845 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
846 filehdr_out
->f_symptr
);
847 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
848 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
849 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
851 /* Put in extra dos header stuff. This data remains essentially
852 constant, it just has to be tacked on to the beginning of all exes
854 H_PUT_16 (abfd
, filehdr_in
->pe
.e_magic
, filehdr_out
->e_magic
);
855 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cblp
, filehdr_out
->e_cblp
);
856 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cp
, filehdr_out
->e_cp
);
857 H_PUT_16 (abfd
, filehdr_in
->pe
.e_crlc
, filehdr_out
->e_crlc
);
858 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cparhdr
, filehdr_out
->e_cparhdr
);
859 H_PUT_16 (abfd
, filehdr_in
->pe
.e_minalloc
, filehdr_out
->e_minalloc
);
860 H_PUT_16 (abfd
, filehdr_in
->pe
.e_maxalloc
, filehdr_out
->e_maxalloc
);
861 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ss
, filehdr_out
->e_ss
);
862 H_PUT_16 (abfd
, filehdr_in
->pe
.e_sp
, filehdr_out
->e_sp
);
863 H_PUT_16 (abfd
, filehdr_in
->pe
.e_csum
, filehdr_out
->e_csum
);
864 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ip
, filehdr_out
->e_ip
);
865 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cs
, filehdr_out
->e_cs
);
866 H_PUT_16 (abfd
, filehdr_in
->pe
.e_lfarlc
, filehdr_out
->e_lfarlc
);
867 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ovno
, filehdr_out
->e_ovno
);
869 for (idx
= 0; idx
< 4; idx
++)
870 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res
[idx
], filehdr_out
->e_res
[idx
]);
872 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oemid
, filehdr_out
->e_oemid
);
873 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oeminfo
, filehdr_out
->e_oeminfo
);
875 for (idx
= 0; idx
< 10; idx
++)
876 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res2
[idx
], filehdr_out
->e_res2
[idx
]);
878 H_PUT_32 (abfd
, filehdr_in
->pe
.e_lfanew
, filehdr_out
->e_lfanew
);
880 for (idx
= 0; idx
< 16; idx
++)
881 H_PUT_32 (abfd
, filehdr_in
->pe
.dos_message
[idx
],
882 filehdr_out
->dos_message
[idx
]);
884 /* Also put in the NT signature. */
885 H_PUT_32 (abfd
, filehdr_in
->pe
.nt_signature
, filehdr_out
->nt_signature
);
891 _bfd_XX_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
893 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
894 FILHDR
*filehdr_out
= (FILHDR
*) out
;
896 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
897 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
898 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->f_timdat
);
899 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
, filehdr_out
->f_symptr
);
900 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
901 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
902 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
908 _bfd_XXi_swap_scnhdr_out (bfd
* abfd
, void * in
, void * out
)
910 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*) in
;
911 SCNHDR
*scnhdr_ext
= (SCNHDR
*) out
;
912 unsigned int ret
= SCNHSZ
;
916 memcpy (scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof (scnhdr_int
->s_name
));
918 ss
= scnhdr_int
->s_vaddr
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
919 if (scnhdr_int
->s_vaddr
< pe_data (abfd
)->pe_opthdr
.ImageBase
)
920 _bfd_error_handler (_("%pB:%.8s: section below image base"),
921 abfd
, scnhdr_int
->s_name
);
922 /* Do not compare lower 32-bits for 64-bit vma. */
923 #if !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
924 else if(ss
!= (ss
& 0xffffffff))
925 _bfd_error_handler (_("%pB:%.8s: RVA truncated"), abfd
, scnhdr_int
->s_name
);
926 PUT_SCNHDR_VADDR (abfd
, ss
& 0xffffffff, scnhdr_ext
->s_vaddr
);
928 PUT_SCNHDR_VADDR (abfd
, ss
, scnhdr_ext
->s_vaddr
);
931 /* NT wants the size data to be rounded up to the next
932 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
934 if ((scnhdr_int
->s_flags
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
) != 0)
936 if (bfd_pei_p (abfd
))
938 ps
= scnhdr_int
->s_size
;
944 ss
= scnhdr_int
->s_size
;
949 if (bfd_pei_p (abfd
))
950 ps
= scnhdr_int
->s_paddr
;
954 ss
= scnhdr_int
->s_size
;
957 PUT_SCNHDR_SIZE (abfd
, ss
,
960 /* s_paddr in PE is really the virtual size. */
961 PUT_SCNHDR_PADDR (abfd
, ps
, scnhdr_ext
->s_paddr
);
963 PUT_SCNHDR_SCNPTR (abfd
, scnhdr_int
->s_scnptr
,
964 scnhdr_ext
->s_scnptr
);
965 PUT_SCNHDR_RELPTR (abfd
, scnhdr_int
->s_relptr
,
966 scnhdr_ext
->s_relptr
);
967 PUT_SCNHDR_LNNOPTR (abfd
, scnhdr_int
->s_lnnoptr
,
968 scnhdr_ext
->s_lnnoptr
);
971 /* Extra flags must be set when dealing with PE. All sections should also
972 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
973 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
974 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
975 (this is especially important when dealing with the .idata section since
976 the addresses for routines from .dlls must be overwritten). If .reloc
977 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
978 (0x02000000). Also, the resource data should also be read and
981 /* FIXME: Alignment is also encoded in this field, at least on
982 ARM-WINCE. Although - how do we get the original alignment field
987 char section_name
[SCNNMLEN
];
988 unsigned long must_have
;
990 pe_required_section_flags
;
992 pe_required_section_flags known_sections
[] =
994 { ".arch", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
| IMAGE_SCN_ALIGN_8BYTES
},
995 { ".bss", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
996 { ".data", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
997 { ".edata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
998 { ".idata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
999 { ".pdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1000 { ".rdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1001 { ".reloc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
},
1002 { ".rsrc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1003 { ".text" , IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_CODE
| IMAGE_SCN_MEM_EXECUTE
},
1004 { ".tls", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1005 { ".xdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1008 pe_required_section_flags
* p
;
1010 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1011 we know exactly what this specific section wants so we remove it
1012 and then allow the must_have field to add it back in if necessary.
1013 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1014 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
1015 by ld --enable-auto-import (if auto-import is actually needed),
1016 by ld --omagic, or by obcopy --writable-text. */
1018 for (p
= known_sections
;
1019 p
< known_sections
+ ARRAY_SIZE (known_sections
);
1021 if (memcmp (scnhdr_int
->s_name
, p
->section_name
, SCNNMLEN
) == 0)
1023 if (memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text")
1024 || (bfd_get_file_flags (abfd
) & WP_TEXT
))
1025 scnhdr_int
->s_flags
&= ~IMAGE_SCN_MEM_WRITE
;
1026 scnhdr_int
->s_flags
|= p
->must_have
;
1030 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1033 if (coff_data (abfd
)->link_info
1034 && ! bfd_link_relocatable (coff_data (abfd
)->link_info
)
1035 && ! bfd_link_pic (coff_data (abfd
)->link_info
)
1036 && memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text") == 0)
1038 /* By inference from looking at MS output, the 32 bit field
1039 which is the combination of the number_of_relocs and
1040 number_of_linenos is used for the line number count in
1041 executables. A 16-bit field won't do for cc1. The MS
1042 document says that the number of relocs is zero for
1043 executables, but the 17-th bit has been observed to be there.
1044 Overflow is not an issue: a 4G-line program will overflow a
1045 bunch of other fields long before this! */
1046 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
& 0xffff), scnhdr_ext
->s_nlnno
);
1047 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
>> 16), scnhdr_ext
->s_nreloc
);
1051 if (scnhdr_int
->s_nlnno
<= 0xffff)
1052 H_PUT_16 (abfd
, scnhdr_int
->s_nlnno
, scnhdr_ext
->s_nlnno
);
1055 /* xgettext:c-format */
1056 _bfd_error_handler (_("%pB: line number overflow: 0x%lx > 0xffff"),
1057 abfd
, scnhdr_int
->s_nlnno
);
1058 bfd_set_error (bfd_error_file_truncated
);
1059 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nlnno
);
1063 /* Although we could encode 0xffff relocs here, we do not, to be
1064 consistent with other parts of bfd. Also it lets us warn, as
1065 we should never see 0xffff here w/o having the overflow flag
1067 if (scnhdr_int
->s_nreloc
< 0xffff)
1068 H_PUT_16 (abfd
, scnhdr_int
->s_nreloc
, scnhdr_ext
->s_nreloc
);
1071 /* PE can deal with large #s of relocs, but not here. */
1072 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nreloc
);
1073 scnhdr_int
->s_flags
|= IMAGE_SCN_LNK_NRELOC_OVFL
;
1074 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1081 _bfd_XXi_swap_debugdir_in (bfd
* abfd
, void * ext1
, void * in1
)
1083 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) ext1
;
1084 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) in1
;
1086 in
->Characteristics
= H_GET_32(abfd
, ext
->Characteristics
);
1087 in
->TimeDateStamp
= H_GET_32(abfd
, ext
->TimeDateStamp
);
1088 in
->MajorVersion
= H_GET_16(abfd
, ext
->MajorVersion
);
1089 in
->MinorVersion
= H_GET_16(abfd
, ext
->MinorVersion
);
1090 in
->Type
= H_GET_32(abfd
, ext
->Type
);
1091 in
->SizeOfData
= H_GET_32(abfd
, ext
->SizeOfData
);
1092 in
->AddressOfRawData
= H_GET_32(abfd
, ext
->AddressOfRawData
);
1093 in
->PointerToRawData
= H_GET_32(abfd
, ext
->PointerToRawData
);
1097 _bfd_XXi_swap_debugdir_out (bfd
* abfd
, void * inp
, void * extp
)
1099 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) extp
;
1100 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) inp
;
1102 H_PUT_32(abfd
, in
->Characteristics
, ext
->Characteristics
);
1103 H_PUT_32(abfd
, in
->TimeDateStamp
, ext
->TimeDateStamp
);
1104 H_PUT_16(abfd
, in
->MajorVersion
, ext
->MajorVersion
);
1105 H_PUT_16(abfd
, in
->MinorVersion
, ext
->MinorVersion
);
1106 H_PUT_32(abfd
, in
->Type
, ext
->Type
);
1107 H_PUT_32(abfd
, in
->SizeOfData
, ext
->SizeOfData
);
1108 H_PUT_32(abfd
, in
->AddressOfRawData
, ext
->AddressOfRawData
);
1109 H_PUT_32(abfd
, in
->PointerToRawData
, ext
->PointerToRawData
);
1111 return sizeof (struct external_IMAGE_DEBUG_DIRECTORY
);
1115 _bfd_XXi_slurp_codeview_record (bfd
* abfd
, file_ptr where
, unsigned long length
, CODEVIEW_INFO
*cvinfo
,
1119 bfd_size_type nread
;
1121 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1124 if (length
<= sizeof (CV_INFO_PDB70
) && length
<= sizeof (CV_INFO_PDB20
))
1128 nread
= bfd_bread (buffer
, length
, abfd
);
1129 if (length
!= nread
)
1132 /* Ensure null termination of filename. */
1133 memset (buffer
+ nread
, 0, sizeof (buffer
) - nread
);
1135 cvinfo
->CVSignature
= H_GET_32 (abfd
, buffer
);
1138 if ((cvinfo
->CVSignature
== CVINFO_PDB70_CVSIGNATURE
)
1139 && (length
> sizeof (CV_INFO_PDB70
)))
1141 CV_INFO_PDB70
*cvinfo70
= (CV_INFO_PDB70
*)(buffer
);
1143 cvinfo
->Age
= H_GET_32(abfd
, cvinfo70
->Age
);
1145 /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1146 by 8 single bytes. Byte swap them so we can conveniently treat the GUID
1147 as 16 bytes in big-endian order. */
1148 bfd_putb32 (bfd_getl32 (cvinfo70
->Signature
), cvinfo
->Signature
);
1149 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[4])), &(cvinfo
->Signature
[4]));
1150 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[6])), &(cvinfo
->Signature
[6]));
1151 memcpy (&(cvinfo
->Signature
[8]), &(cvinfo70
->Signature
[8]), 8);
1153 cvinfo
->SignatureLength
= CV_INFO_SIGNATURE_LENGTH
;
1154 /* cvinfo->PdbFileName = cvinfo70->PdbFileName; */
1157 *pdb
= xstrdup (cvinfo70
->PdbFileName
);
1161 else if ((cvinfo
->CVSignature
== CVINFO_PDB20_CVSIGNATURE
)
1162 && (length
> sizeof (CV_INFO_PDB20
)))
1164 CV_INFO_PDB20
*cvinfo20
= (CV_INFO_PDB20
*)(buffer
);
1165 cvinfo
->Age
= H_GET_32(abfd
, cvinfo20
->Age
);
1166 memcpy (cvinfo
->Signature
, cvinfo20
->Signature
, 4);
1167 cvinfo
->SignatureLength
= 4;
1168 /* cvinfo->PdbFileName = cvinfo20->PdbFileName; */
1171 *pdb
= xstrdup (cvinfo20
->PdbFileName
);
1180 _bfd_XXi_write_codeview_record (bfd
* abfd
, file_ptr where
, CODEVIEW_INFO
*cvinfo
,
1183 size_t pdb_len
= pdb
? strlen (pdb
) : 0;
1184 const bfd_size_type size
= sizeof (CV_INFO_PDB70
) + pdb_len
+ 1;
1185 bfd_size_type written
;
1186 CV_INFO_PDB70
*cvinfo70
;
1189 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1192 buffer
= bfd_malloc (size
);
1196 cvinfo70
= (CV_INFO_PDB70
*) buffer
;
1197 H_PUT_32 (abfd
, CVINFO_PDB70_CVSIGNATURE
, cvinfo70
->CvSignature
);
1199 /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1200 in little-endian order, followed by 8 single bytes. */
1201 bfd_putl32 (bfd_getb32 (cvinfo
->Signature
), cvinfo70
->Signature
);
1202 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[4])), &(cvinfo70
->Signature
[4]));
1203 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[6])), &(cvinfo70
->Signature
[6]));
1204 memcpy (&(cvinfo70
->Signature
[8]), &(cvinfo
->Signature
[8]), 8);
1206 H_PUT_32 (abfd
, cvinfo
->Age
, cvinfo70
->Age
);
1209 cvinfo70
->PdbFileName
[0] = '\0';
1211 memcpy (cvinfo70
->PdbFileName
, pdb
, pdb_len
+ 1);
1213 written
= bfd_bwrite (buffer
, size
, abfd
);
1217 return written
== size
? size
: 0;
1220 static char * dir_names
[IMAGE_NUMBEROF_DIRECTORY_ENTRIES
] =
1222 N_("Export Directory [.edata (or where ever we found it)]"),
1223 N_("Import Directory [parts of .idata]"),
1224 N_("Resource Directory [.rsrc]"),
1225 N_("Exception Directory [.pdata]"),
1226 N_("Security Directory"),
1227 N_("Base Relocation Directory [.reloc]"),
1228 N_("Debug Directory"),
1229 N_("Description Directory"),
1230 N_("Special Directory"),
1231 N_("Thread Storage Directory [.tls]"),
1232 N_("Load Configuration Directory"),
1233 N_("Bound Import Directory"),
1234 N_("Import Address Table Directory"),
1235 N_("Delay Import Directory"),
1236 N_("CLR Runtime Header"),
1241 get_contents_sanity_check (bfd
*abfd
, asection
*section
,
1242 bfd_size_type dataoff
, bfd_size_type datasize
)
1244 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
1246 if (dataoff
> section
->size
1247 || datasize
> section
->size
- dataoff
)
1249 ufile_ptr filesize
= bfd_get_file_size (abfd
);
1251 && ((ufile_ptr
) section
->filepos
> filesize
1252 || dataoff
> filesize
- section
->filepos
1253 || datasize
> filesize
- section
->filepos
- dataoff
))
1259 pe_print_idata (bfd
* abfd
, void * vfile
)
1261 FILE *file
= (FILE *) vfile
;
1265 bfd_size_type datasize
= 0;
1266 bfd_size_type dataoff
;
1270 pe_data_type
*pe
= pe_data (abfd
);
1271 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1275 addr
= extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
;
1277 if (addr
== 0 && extra
->DataDirectory
[PE_IMPORT_TABLE
].Size
== 0)
1279 /* Maybe the extra header isn't there. Look for the section. */
1280 section
= bfd_get_section_by_name (abfd
, ".idata");
1281 if (section
== NULL
|| (section
->flags
& SEC_HAS_CONTENTS
) == 0)
1284 addr
= section
->vma
;
1285 datasize
= section
->size
;
1291 addr
+= extra
->ImageBase
;
1292 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1294 datasize
= section
->size
;
1295 if (addr
>= section
->vma
&& addr
< section
->vma
+ datasize
)
1299 if (section
== NULL
)
1302 _("\nThere is an import table, but the section containing it could not be found\n"));
1305 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1308 _("\nThere is an import table in %s, but that section has no contents\n"),
1314 /* xgettext:c-format */
1315 fprintf (file
, _("\nThere is an import table in %s at 0x%lx\n"),
1316 section
->name
, (unsigned long) addr
);
1318 dataoff
= addr
- section
->vma
;
1321 _("\nThe Import Tables (interpreted %s section contents)\n"),
1325 vma: Hint Time Forward DLL First\n\
1326 Table Stamp Chain Name Thunk\n"));
1328 /* Read the whole section. Some of the fields might be before dataoff. */
1329 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
1335 adj
= section
->vma
- extra
->ImageBase
;
1337 /* Print all image import descriptors. */
1338 for (i
= dataoff
; i
+ onaline
<= datasize
; i
+= onaline
)
1342 bfd_vma forward_chain
;
1344 bfd_vma first_thunk
;
1349 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1350 fprintf (file
, " %08lx\t", (unsigned long) (i
+ adj
));
1351 hint_addr
= bfd_get_32 (abfd
, data
+ i
);
1352 time_stamp
= bfd_get_32 (abfd
, data
+ i
+ 4);
1353 forward_chain
= bfd_get_32 (abfd
, data
+ i
+ 8);
1354 dll_name
= bfd_get_32 (abfd
, data
+ i
+ 12);
1355 first_thunk
= bfd_get_32 (abfd
, data
+ i
+ 16);
1357 fprintf (file
, "%08lx %08lx %08lx %08lx %08lx\n",
1358 (unsigned long) hint_addr
,
1359 (unsigned long) time_stamp
,
1360 (unsigned long) forward_chain
,
1361 (unsigned long) dll_name
,
1362 (unsigned long) first_thunk
);
1364 if (hint_addr
== 0 && first_thunk
== 0)
1367 if (dll_name
- adj
>= section
->size
)
1370 dll
= (char *) data
+ dll_name
- adj
;
1371 /* PR 17512 file: 078-12277-0.004. */
1372 bfd_size_type maxlen
= (char *)(data
+ datasize
) - dll
- 1;
1373 fprintf (file
, _("\n\tDLL Name: %.*s\n"), (int) maxlen
, dll
);
1375 /* PR 21546: When the Hint Address is zero,
1376 we try the First Thunk instead. */
1378 hint_addr
= first_thunk
;
1380 if (hint_addr
!= 0 && hint_addr
- adj
< datasize
)
1383 asection
*ft_section
;
1385 bfd_size_type ft_datasize
;
1389 fprintf (file
, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1391 idx
= hint_addr
- adj
;
1393 ft_addr
= first_thunk
+ extra
->ImageBase
;
1394 ft_idx
= first_thunk
- adj
;
1395 ft_data
= data
+ ft_idx
;
1396 ft_datasize
= datasize
- ft_idx
;
1399 if (first_thunk
!= hint_addr
)
1401 /* Find the section which contains the first thunk. */
1402 for (ft_section
= abfd
->sections
;
1404 ft_section
= ft_section
->next
)
1406 if (ft_addr
>= ft_section
->vma
1407 && ft_addr
< ft_section
->vma
+ ft_section
->size
)
1411 if (ft_section
== NULL
)
1414 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1418 /* Now check to see if this section is the same as our current
1419 section. If it is not then we will have to load its data in. */
1420 if (ft_section
!= section
)
1422 ft_idx
= first_thunk
- (ft_section
->vma
- extra
->ImageBase
);
1423 ft_datasize
= ft_section
->size
- ft_idx
;
1424 if (!get_contents_sanity_check (abfd
, ft_section
,
1425 ft_idx
, ft_datasize
))
1427 ft_data
= (bfd_byte
*) bfd_malloc (ft_datasize
);
1428 if (ft_data
== NULL
)
1431 /* Read ft_datasize bytes starting at offset ft_idx. */
1432 if (!bfd_get_section_contents (abfd
, ft_section
, ft_data
,
1433 (bfd_vma
) ft_idx
, ft_datasize
))
1442 /* Print HintName vector entries. */
1443 #ifdef COFF_WITH_pex64
1444 for (j
= 0; idx
+ j
+ 8 <= datasize
; j
+= 8)
1447 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1448 unsigned long member_high
= bfd_get_32 (abfd
, data
+ idx
+ j
+ 4);
1450 if (!member
&& !member_high
)
1455 if (HighBitSet (member_high
))
1456 fprintf (file
, "\t%lx%08lx\t %4lx%08lx <none>",
1457 member_high
, member
,
1458 WithoutHighBit (member_high
), member
);
1459 /* PR binutils/17512: Handle corrupt PE data. */
1460 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1461 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1467 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1468 member_name
= (char *) data
+ amt
+ 2;
1469 fprintf (file
, "\t%04lx\t %4d %.*s",member
, ordinal
,
1470 (int) (datasize
- (amt
+ 2)), member_name
);
1473 /* If the time stamp is not zero, the import address
1474 table holds actual addresses. */
1477 && first_thunk
!= hint_addr
1478 && j
+ 4 <= ft_datasize
)
1479 fprintf (file
, "\t%04lx",
1480 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1481 fprintf (file
, "\n");
1484 for (j
= 0; idx
+ j
+ 4 <= datasize
; j
+= 4)
1487 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1489 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1495 if (HighBitSet (member
))
1496 fprintf (file
, "\t%04lx\t %4lu <none>",
1497 member
, WithoutHighBit (member
));
1498 /* PR binutils/17512: Handle corrupt PE data. */
1499 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1500 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1506 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1507 member_name
= (char *) data
+ amt
+ 2;
1508 fprintf (file
, "\t%04lx\t %4d %.*s",
1510 (int) (datasize
- (amt
+ 2)), member_name
);
1513 /* If the time stamp is not zero, the import address
1514 table holds actual addresses. */
1517 && first_thunk
!= hint_addr
1518 && j
+ 4 <= ft_datasize
)
1519 fprintf (file
, "\t%04lx",
1520 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1522 fprintf (file
, "\n");
1529 fprintf (file
, "\n");
1538 pe_print_edata (bfd
* abfd
, void * vfile
)
1540 FILE *file
= (FILE *) vfile
;
1543 bfd_size_type datasize
= 0;
1544 bfd_size_type dataoff
;
1549 long export_flags
; /* Reserved - should be zero. */
1553 bfd_vma name
; /* RVA - relative to image base. */
1554 long base
; /* Ordinal base. */
1555 unsigned long num_functions
;/* Number in the export address table. */
1556 unsigned long num_names
; /* Number in the name pointer table. */
1557 bfd_vma eat_addr
; /* RVA to the export address table. */
1558 bfd_vma npt_addr
; /* RVA to the Export Name Pointer Table. */
1559 bfd_vma ot_addr
; /* RVA to the Ordinal Table. */
1562 pe_data_type
*pe
= pe_data (abfd
);
1563 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1567 addr
= extra
->DataDirectory
[PE_EXPORT_TABLE
].VirtualAddress
;
1569 if (addr
== 0 && extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
== 0)
1571 /* Maybe the extra header isn't there. Look for the section. */
1572 section
= bfd_get_section_by_name (abfd
, ".edata");
1573 if (section
== NULL
)
1576 addr
= section
->vma
;
1578 datasize
= section
->size
;
1584 addr
+= extra
->ImageBase
;
1586 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1587 if (addr
>= section
->vma
&& addr
< section
->vma
+ section
->size
)
1590 if (section
== NULL
)
1593 _("\nThere is an export table, but the section containing it could not be found\n"));
1597 dataoff
= addr
- section
->vma
;
1598 datasize
= extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
;
1601 /* PR 17512: Handle corrupt PE binaries. */
1605 /* xgettext:c-format */
1606 _("\nThere is an export table in %s, but it is too small (%d)\n"),
1607 section
->name
, (int) datasize
);
1611 if (!get_contents_sanity_check (abfd
, section
, dataoff
, datasize
))
1614 _("\nThere is an export table in %s, but contents cannot be read\n"),
1619 /* xgettext:c-format */
1620 fprintf (file
, _("\nThere is an export table in %s at 0x%lx\n"),
1621 section
->name
, (unsigned long) addr
);
1623 data
= (bfd_byte
*) bfd_malloc (datasize
);
1627 if (! bfd_get_section_contents (abfd
, section
, data
,
1628 (file_ptr
) dataoff
, datasize
))
1634 /* Go get Export Directory Table. */
1635 edt
.export_flags
= bfd_get_32 (abfd
, data
+ 0);
1636 edt
.time_stamp
= bfd_get_32 (abfd
, data
+ 4);
1637 edt
.major_ver
= bfd_get_16 (abfd
, data
+ 8);
1638 edt
.minor_ver
= bfd_get_16 (abfd
, data
+ 10);
1639 edt
.name
= bfd_get_32 (abfd
, data
+ 12);
1640 edt
.base
= bfd_get_32 (abfd
, data
+ 16);
1641 edt
.num_functions
= bfd_get_32 (abfd
, data
+ 20);
1642 edt
.num_names
= bfd_get_32 (abfd
, data
+ 24);
1643 edt
.eat_addr
= bfd_get_32 (abfd
, data
+ 28);
1644 edt
.npt_addr
= bfd_get_32 (abfd
, data
+ 32);
1645 edt
.ot_addr
= bfd_get_32 (abfd
, data
+ 36);
1647 adj
= section
->vma
- extra
->ImageBase
+ dataoff
;
1649 /* Dump the EDT first. */
1651 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1655 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt
.export_flags
);
1658 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt
.time_stamp
);
1661 /* xgettext:c-format */
1662 _("Major/Minor \t\t\t%d/%d\n"), edt
.major_ver
, edt
.minor_ver
);
1665 _("Name \t\t\t\t"));
1666 bfd_fprintf_vma (abfd
, file
, edt
.name
);
1668 if ((edt
.name
>= adj
) && (edt
.name
< adj
+ datasize
))
1669 fprintf (file
, " %.*s\n",
1670 (int) (datasize
- (edt
.name
- adj
)),
1671 data
+ edt
.name
- adj
);
1673 fprintf (file
, "(outside .edata section)\n");
1676 _("Ordinal Base \t\t\t%ld\n"), edt
.base
);
1682 _("\tExport Address Table \t\t%08lx\n"),
1686 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt
.num_names
);
1689 _("Table Addresses\n"));
1692 _("\tExport Address Table \t\t"));
1693 bfd_fprintf_vma (abfd
, file
, edt
.eat_addr
);
1694 fprintf (file
, "\n");
1697 _("\tName Pointer Table \t\t"));
1698 bfd_fprintf_vma (abfd
, file
, edt
.npt_addr
);
1699 fprintf (file
, "\n");
1702 _("\tOrdinal Table \t\t\t"));
1703 bfd_fprintf_vma (abfd
, file
, edt
.ot_addr
);
1704 fprintf (file
, "\n");
1706 /* The next table to find is the Export Address Table. It's basically
1707 a list of pointers that either locate a function in this dll, or
1708 forward the call to another dll. Something like:
1713 } export_address_table_entry; */
1716 _("\nExport Address Table -- Ordinal Base %ld\n"),
1719 /* PR 17512: Handle corrupt PE binaries. */
1720 /* PR 17512 file: 140-165018-0.004. */
1721 if (edt
.eat_addr
- adj
>= datasize
1722 /* PR 17512: file: 092b1829 */
1723 || (edt
.num_functions
+ 1) * 4 < edt
.num_functions
1724 || edt
.eat_addr
- adj
+ (edt
.num_functions
+ 1) * 4 > datasize
)
1725 fprintf (file
, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1726 (long) edt
.eat_addr
,
1727 (long) edt
.num_functions
);
1728 else for (i
= 0; i
< edt
.num_functions
; ++i
)
1730 bfd_vma eat_member
= bfd_get_32 (abfd
,
1731 data
+ edt
.eat_addr
+ (i
* 4) - adj
);
1732 if (eat_member
== 0)
1735 if (eat_member
- adj
<= datasize
)
1737 /* This rva is to a name (forwarding function) in our section. */
1738 /* Should locate a function descriptor. */
1740 "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1742 (long) (i
+ edt
.base
),
1743 (unsigned long) eat_member
,
1745 (int)(datasize
- (eat_member
- adj
)),
1746 data
+ eat_member
- adj
);
1750 /* Should locate a function descriptor in the reldata section. */
1752 "\t[%4ld] +base[%4ld] %04lx %s\n",
1754 (long) (i
+ edt
.base
),
1755 (unsigned long) eat_member
,
1760 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1761 /* Dump them in parallel for clarity. */
1763 _("\n[Ordinal/Name Pointer] Table\n"));
1765 /* PR 17512: Handle corrupt PE binaries. */
1766 if (edt
.npt_addr
+ (edt
.num_names
* 4) - adj
>= datasize
1767 /* PR 17512: file: bb68816e. */
1768 || edt
.num_names
* 4 < edt
.num_names
1769 || (data
+ edt
.npt_addr
- adj
) < data
)
1770 /* xgettext:c-format */
1771 fprintf (file
, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1772 (long) edt
.npt_addr
,
1773 (long) edt
.num_names
);
1774 /* PR 17512: file: 140-147171-0.004. */
1775 else if (edt
.ot_addr
+ (edt
.num_names
* 2) - adj
>= datasize
1776 || data
+ edt
.ot_addr
- adj
< data
)
1777 /* xgettext:c-format */
1778 fprintf (file
, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1780 (long) edt
.num_names
);
1781 else for (i
= 0; i
< edt
.num_names
; ++i
)
1786 ord
= bfd_get_16 (abfd
, data
+ edt
.ot_addr
+ (i
* 2) - adj
);
1787 name_ptr
= bfd_get_32 (abfd
, data
+ edt
.npt_addr
+ (i
* 4) - adj
);
1789 if ((name_ptr
- adj
) >= datasize
)
1791 /* xgettext:c-format */
1792 fprintf (file
, _("\t[%4ld] <corrupt offset: %lx>\n"),
1793 (long) ord
, (long) name_ptr
);
1797 char * name
= (char *) data
+ name_ptr
- adj
;
1799 fprintf (file
, "\t[%4ld] %.*s\n", (long) ord
,
1800 (int)((char *)(data
+ datasize
) - name
), name
);
1809 /* This really is architecture dependent. On IA-64, a .pdata entry
1810 consists of three dwords containing relative virtual addresses that
1811 specify the start and end address of the code range the entry
1812 covers and the address of the corresponding unwind info data.
1814 On ARM and SH-4, a compressed PDATA structure is used :
1815 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1816 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1817 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1819 This is the version for uncompressed data. */
1822 pe_print_pdata (bfd
* abfd
, void * vfile
)
1824 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
1825 # define PDATA_ROW_SIZE (3 * 8)
1827 # define PDATA_ROW_SIZE (5 * 4)
1829 FILE *file
= (FILE *) vfile
;
1831 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1832 bfd_size_type datasize
= 0;
1834 bfd_size_type start
, stop
;
1835 int onaline
= PDATA_ROW_SIZE
;
1838 || (section
->flags
& SEC_HAS_CONTENTS
) == 0
1839 || coff_section_data (abfd
, section
) == NULL
1840 || pei_section_data (abfd
, section
) == NULL
)
1843 stop
= pei_section_data (abfd
, section
)->virt_size
;
1844 if ((stop
% onaline
) != 0)
1846 /* xgettext:c-format */
1847 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
1848 (long) stop
, onaline
);
1851 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1852 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
1854 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1857 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1858 \t\tAddress Address Handler Data Address Mask\n"));
1861 datasize
= section
->size
;
1865 /* PR 17512: file: 002-193900-0.004. */
1866 if (datasize
< stop
)
1868 /* xgettext:c-format */
1869 fprintf (file
, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"),
1870 (long) stop
, (long) datasize
);
1874 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
1882 for (i
= start
; i
< stop
; i
+= onaline
)
1888 bfd_vma prolog_end_addr
;
1889 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64)
1893 if (i
+ PDATA_ROW_SIZE
> stop
)
1896 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
1897 end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
1898 eh_handler
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 8);
1899 eh_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 12);
1900 prolog_end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 16);
1902 if (begin_addr
== 0 && end_addr
== 0 && eh_handler
== 0
1903 && eh_data
== 0 && prolog_end_addr
== 0)
1904 /* We are probably into the padding of the section now. */
1907 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64)
1908 em_data
= ((eh_handler
& 0x1) << 2) | (prolog_end_addr
& 0x3);
1910 eh_handler
&= ~(bfd_vma
) 0x3;
1911 prolog_end_addr
&= ~(bfd_vma
) 0x3;
1914 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
1915 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
1916 bfd_fprintf_vma (abfd
, file
, end_addr
); fputc (' ', file
);
1917 bfd_fprintf_vma (abfd
, file
, eh_handler
);
1918 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64)
1920 bfd_fprintf_vma (abfd
, file
, eh_data
); fputc (' ', file
);
1921 bfd_fprintf_vma (abfd
, file
, prolog_end_addr
);
1922 fprintf (file
, " %x", em_data
);
1924 fprintf (file
, "\n");
1930 #undef PDATA_ROW_SIZE
1933 typedef struct sym_cache
1940 slurp_symtab (bfd
*abfd
, sym_cache
*psc
)
1942 asymbol
** sy
= NULL
;
1945 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1951 storage
= bfd_get_symtab_upper_bound (abfd
);
1956 sy
= (asymbol
**) bfd_malloc (storage
);
1961 psc
->symcount
= bfd_canonicalize_symtab (abfd
, sy
);
1962 if (psc
->symcount
< 0)
1968 my_symbol_for_address (bfd
*abfd
, bfd_vma func
, sym_cache
*psc
)
1973 psc
->syms
= slurp_symtab (abfd
, psc
);
1975 for (i
= 0; i
< psc
->symcount
; i
++)
1977 if (psc
->syms
[i
]->section
->vma
+ psc
->syms
[i
]->value
== func
)
1978 return psc
->syms
[i
]->name
;
1985 cleanup_syms (sym_cache
*psc
)
1992 /* This is the version for "compressed" pdata. */
1995 _bfd_XX_print_ce_compressed_pdata (bfd
* abfd
, void * vfile
)
1997 # define PDATA_ROW_SIZE (2 * 4)
1998 FILE *file
= (FILE *) vfile
;
1999 bfd_byte
*data
= NULL
;
2000 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
2001 bfd_size_type datasize
= 0;
2003 bfd_size_type start
, stop
;
2004 int onaline
= PDATA_ROW_SIZE
;
2005 struct sym_cache cache
= {0, 0} ;
2008 || (section
->flags
& SEC_HAS_CONTENTS
) == 0
2009 || coff_section_data (abfd
, section
) == NULL
2010 || pei_section_data (abfd
, section
) == NULL
)
2013 stop
= pei_section_data (abfd
, section
)->virt_size
;
2014 if ((stop
% onaline
) != 0)
2016 /* xgettext:c-format */
2017 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
2018 (long) stop
, onaline
);
2021 _("\nThe Function Table (interpreted .pdata section contents)\n"));
2024 vma:\t\tBegin Prolog Function Flags Exception EH\n\
2025 \t\tAddress Length Length 32b exc Handler Data\n"));
2027 datasize
= section
->size
;
2031 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2038 if (stop
> datasize
)
2041 for (i
= start
; i
< stop
; i
+= onaline
)
2045 bfd_vma prolog_length
, function_length
;
2046 int flag32bit
, exception_flag
;
2049 if (i
+ PDATA_ROW_SIZE
> stop
)
2052 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
2053 other_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
2055 if (begin_addr
== 0 && other_data
== 0)
2056 /* We are probably into the padding of the section now. */
2059 prolog_length
= (other_data
& 0x000000FF);
2060 function_length
= (other_data
& 0x3FFFFF00) >> 8;
2061 flag32bit
= (int)((other_data
& 0x40000000) >> 30);
2062 exception_flag
= (int)((other_data
& 0x80000000) >> 31);
2065 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
2066 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
2067 bfd_fprintf_vma (abfd
, file
, prolog_length
); fputc (' ', file
);
2068 bfd_fprintf_vma (abfd
, file
, function_length
); fputc (' ', file
);
2069 fprintf (file
, "%2d %2d ", flag32bit
, exception_flag
);
2071 /* Get the exception handler's address and the data passed from the
2072 .text section. This is really the data that belongs with the .pdata
2073 but got "compressed" out for the ARM and SH4 architectures. */
2074 tsection
= bfd_get_section_by_name (abfd
, ".text");
2075 if (tsection
&& coff_section_data (abfd
, tsection
)
2076 && pei_section_data (abfd
, tsection
))
2078 bfd_vma eh_off
= (begin_addr
- 8) - tsection
->vma
;
2081 tdata
= (bfd_byte
*) bfd_malloc (8);
2084 if (bfd_get_section_contents (abfd
, tsection
, tdata
, eh_off
, 8))
2086 bfd_vma eh
, eh_data
;
2088 eh
= bfd_get_32 (abfd
, tdata
);
2089 eh_data
= bfd_get_32 (abfd
, tdata
+ 4);
2090 fprintf (file
, "%08x ", (unsigned int) eh
);
2091 fprintf (file
, "%08x", (unsigned int) eh_data
);
2094 const char *s
= my_symbol_for_address (abfd
, eh
, &cache
);
2097 fprintf (file
, " (%s) ", s
);
2104 fprintf (file
, "\n");
2109 cleanup_syms (& cache
);
2112 #undef PDATA_ROW_SIZE
2116 #define IMAGE_REL_BASED_HIGHADJ 4
2117 static const char * const tbl
[] =
2131 "UNKNOWN", /* MUST be last. */
2135 pe_print_reloc (bfd
* abfd
, void * vfile
)
2137 FILE *file
= (FILE *) vfile
;
2139 asection
*section
= bfd_get_section_by_name (abfd
, ".reloc");
2143 || section
->size
== 0
2144 || (section
->flags
& SEC_HAS_CONTENTS
) == 0)
2148 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2150 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2157 end
= data
+ section
->size
;
2158 while (p
+ 8 <= end
)
2161 bfd_vma virtual_address
;
2162 unsigned long number
, size
;
2163 bfd_byte
*chunk_end
;
2165 /* The .reloc section is a sequence of blocks, with a header consisting
2166 of two 32 bit quantities, followed by a number of 16 bit entries. */
2167 virtual_address
= bfd_get_32 (abfd
, p
);
2168 size
= bfd_get_32 (abfd
, p
+ 4);
2170 number
= (size
- 8) / 2;
2176 /* xgettext:c-format */
2177 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2178 (unsigned long) virtual_address
, size
, size
, number
);
2180 chunk_end
= p
- 8 + size
;
2181 if (chunk_end
> end
)
2184 while (p
+ 2 <= chunk_end
)
2186 unsigned short e
= bfd_get_16 (abfd
, p
);
2187 unsigned int t
= (e
& 0xF000) >> 12;
2188 int off
= e
& 0x0FFF;
2190 if (t
>= sizeof (tbl
) / sizeof (tbl
[0]))
2191 t
= (sizeof (tbl
) / sizeof (tbl
[0])) - 1;
2194 /* xgettext:c-format */
2195 _("\treloc %4d offset %4x [%4lx] %s"),
2196 j
, off
, (unsigned long) (off
+ virtual_address
), tbl
[t
]);
2201 /* HIGHADJ takes an argument, - the next record *is* the
2202 low 16 bits of addend. */
2203 if (t
== IMAGE_REL_BASED_HIGHADJ
&& p
+ 2 <= chunk_end
)
2205 fprintf (file
, " (%4x)", (unsigned int) bfd_get_16 (abfd
, p
));
2210 fprintf (file
, "\n");
2219 /* A data structure describing the regions of a .rsrc section.
2220 Some fields are filled in as the section is parsed. */
2222 typedef struct rsrc_regions
2224 bfd_byte
* section_start
;
2225 bfd_byte
* section_end
;
2226 bfd_byte
* strings_start
;
2227 bfd_byte
* resource_start
;
2231 rsrc_print_resource_directory (FILE * , bfd
*, unsigned int, bfd_byte
*,
2232 rsrc_regions
*, bfd_vma
);
2234 /* Print the resource entry at DATA, with the text indented by INDENT.
2235 Recusively calls rsrc_print_resource_directory to print the contents
2236 of directory entries.
2237 Returns the address of the end of the data associated with the entry
2238 or section_end + 1 upon failure. */
2241 rsrc_print_resource_entries (FILE *file
,
2243 unsigned int indent
,
2246 rsrc_regions
*regions
,
2249 unsigned long entry
, addr
, size
;
2252 if (data
+ 8 >= regions
->section_end
)
2253 return regions
->section_end
+ 1;
2255 /* xgettext:c-format */
2256 fprintf (file
, _("%03x %*.s Entry: "), (int)(data
- regions
->section_start
), indent
, " ");
2258 entry
= (unsigned long) bfd_get_32 (abfd
, data
);
2263 /* Note - the documentation says that this field is an RVA value
2264 but windres appears to produce a section relative offset with
2265 the top bit set. Support both styles for now. */
2266 if (HighBitSet (entry
))
2267 name
= regions
->section_start
+ WithoutHighBit (entry
);
2269 name
= regions
->section_start
+ entry
- rva_bias
;
2271 if (name
+ 2 < regions
->section_end
&& name
> regions
->section_start
)
2275 if (regions
->strings_start
== NULL
)
2276 regions
->strings_start
= name
;
2278 len
= bfd_get_16 (abfd
, name
);
2280 fprintf (file
, _("name: [val: %08lx len %d]: "), entry
, len
);
2282 if (name
+ 2 + len
* 2 < regions
->section_end
)
2284 /* This strange loop is to cope with multibyte characters. */
2291 /* Avoid printing control characters. */
2292 if (c
> 0 && c
< 32)
2293 fprintf (file
, "^%c", c
+ 64);
2295 fprintf (file
, "%.1s", name
);
2300 fprintf (file
, _("<corrupt string length: %#x>\n"), len
);
2301 /* PR binutils/17512: Do not try to continue decoding a
2302 corrupted resource section. It is likely to end up with
2303 reams of extraneous output. FIXME: We could probably
2304 continue if we disable the printing of strings... */
2305 return regions
->section_end
+ 1;
2310 fprintf (file
, _("<corrupt string offset: %#lx>\n"), entry
);
2311 return regions
->section_end
+ 1;
2315 fprintf (file
, _("ID: %#08lx"), entry
);
2317 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
2318 fprintf (file
, _(", Value: %#08lx\n"), entry
);
2320 if (HighBitSet (entry
))
2322 data
= regions
->section_start
+ WithoutHighBit (entry
);
2323 if (data
<= regions
->section_start
|| data
> regions
->section_end
)
2324 return regions
->section_end
+ 1;
2326 /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2327 in the resource table. We need some way to detect this. */
2328 return rsrc_print_resource_directory (file
, abfd
, indent
+ 1, data
,
2332 leaf
= regions
->section_start
+ entry
;
2334 if (leaf
+ 16 >= regions
->section_end
2335 /* PR 17512: file: 055dff7e. */
2336 || leaf
< regions
->section_start
)
2337 return regions
->section_end
+ 1;
2339 /* xgettext:c-format */
2340 fprintf (file
, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2341 (int) (entry
), indent
, " ",
2342 addr
= (long) bfd_get_32 (abfd
, leaf
),
2343 size
= (long) bfd_get_32 (abfd
, leaf
+ 4),
2344 (int) bfd_get_32 (abfd
, leaf
+ 8));
2346 /* Check that the reserved entry is 0. */
2347 if (bfd_get_32 (abfd
, leaf
+ 12) != 0
2348 /* And that the data address/size is valid too. */
2349 || (regions
->section_start
+ (addr
- rva_bias
) + size
> regions
->section_end
))
2350 return regions
->section_end
+ 1;
2352 if (regions
->resource_start
== NULL
)
2353 regions
->resource_start
= regions
->section_start
+ (addr
- rva_bias
);
2355 return regions
->section_start
+ (addr
- rva_bias
) + size
;
2358 #define max(a,b) ((a) > (b) ? (a) : (b))
2359 #define min(a,b) ((a) < (b) ? (a) : (b))
2362 rsrc_print_resource_directory (FILE * file
,
2364 unsigned int indent
,
2366 rsrc_regions
* regions
,
2369 unsigned int num_names
, num_ids
;
2370 bfd_byte
* highest_data
= data
;
2372 if (data
+ 16 >= regions
->section_end
)
2373 return regions
->section_end
+ 1;
2375 fprintf (file
, "%03x %*.s ", (int)(data
- regions
->section_start
), indent
, " ");
2378 case 0: fprintf (file
, "Type"); break;
2379 case 2: fprintf (file
, "Name"); break;
2380 case 4: fprintf (file
, "Language"); break;
2382 fprintf (file
, _("<unknown directory type: %d>\n"), indent
);
2383 /* FIXME: For now we end the printing here. If in the
2384 future more directory types are added to the RSRC spec
2385 then we will need to change this. */
2386 return regions
->section_end
+ 1;
2389 /* xgettext:c-format */
2390 fprintf (file
, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2391 (int) bfd_get_32 (abfd
, data
),
2392 (long) bfd_get_32 (abfd
, data
+ 4),
2393 (int) bfd_get_16 (abfd
, data
+ 8),
2394 (int) bfd_get_16 (abfd
, data
+ 10),
2395 num_names
= (int) bfd_get_16 (abfd
, data
+ 12),
2396 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14));
2399 while (num_names
--)
2401 bfd_byte
* entry_end
;
2403 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, true,
2404 data
, regions
, rva_bias
);
2406 highest_data
= max (highest_data
, entry_end
);
2407 if (entry_end
>= regions
->section_end
)
2413 bfd_byte
* entry_end
;
2415 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, false,
2416 data
, regions
, rva_bias
);
2418 highest_data
= max (highest_data
, entry_end
);
2419 if (entry_end
>= regions
->section_end
)
2423 return max (highest_data
, data
);
2426 /* Display the contents of a .rsrc section. We do not try to
2427 reproduce the resources, windres does that. Instead we dump
2428 the tables in a human readable format. */
2431 rsrc_print_section (bfd
* abfd
, void * vfile
)
2435 FILE * file
= (FILE *) vfile
;
2436 bfd_size_type datasize
;
2439 rsrc_regions regions
;
2441 pe
= pe_data (abfd
);
2445 section
= bfd_get_section_by_name (abfd
, ".rsrc");
2446 if (section
== NULL
)
2448 if (!(section
->flags
& SEC_HAS_CONTENTS
))
2451 datasize
= section
->size
;
2455 rva_bias
= section
->vma
- pe
->pe_opthdr
.ImageBase
;
2457 if (! bfd_malloc_and_get_section (abfd
, section
, & data
))
2463 regions
.section_start
= data
;
2464 regions
.section_end
= data
+ datasize
;
2465 regions
.strings_start
= NULL
;
2466 regions
.resource_start
= NULL
;
2469 fprintf (file
, "\nThe .rsrc Resource Directory section:\n");
2471 while (data
< regions
.section_end
)
2473 bfd_byte
* p
= data
;
2475 data
= rsrc_print_resource_directory (file
, abfd
, 0, data
, & regions
, rva_bias
);
2477 if (data
== regions
.section_end
+ 1)
2478 fprintf (file
, _("Corrupt .rsrc section detected!\n"));
2481 /* Align data before continuing. */
2482 int align
= (1 << section
->alignment_power
) - 1;
2484 data
= (bfd_byte
*) (((ptrdiff_t) (data
+ align
)) & ~ align
);
2485 rva_bias
+= data
- p
;
2487 /* For reasons that are unclear .rsrc sections are sometimes created
2488 aligned to a 1^3 boundary even when their alignment is set at
2489 1^2. Catch that case here before we issue a spurious warning
2491 if (data
== (regions
.section_end
- 4))
2492 data
= regions
.section_end
;
2493 else if (data
< regions
.section_end
)
2495 /* If the extra data is all zeros then do not complain.
2496 This is just padding so that the section meets the
2497 page size requirements. */
2498 while (++ data
< regions
.section_end
)
2501 if (data
< regions
.section_end
)
2502 fprintf (file
, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2507 if (regions
.strings_start
!= NULL
)
2508 fprintf (file
, _(" String table starts at offset: %#03x\n"),
2509 (int) (regions
.strings_start
- regions
.section_start
));
2510 if (regions
.resource_start
!= NULL
)
2511 fprintf (file
, _(" Resources start at offset: %#03x\n"),
2512 (int) (regions
.resource_start
- regions
.section_start
));
2514 free (regions
.section_start
);
2518 #define IMAGE_NUMBEROF_DEBUG_TYPES 17
2520 static char * debug_type_names
[IMAGE_NUMBEROF_DEBUG_TYPES
] =
2542 pe_print_debugdata (bfd
* abfd
, void * vfile
)
2544 FILE *file
= (FILE *) vfile
;
2545 pe_data_type
*pe
= pe_data (abfd
);
2546 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2549 bfd_size_type dataoff
;
2552 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2553 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2558 addr
+= extra
->ImageBase
;
2559 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2561 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2565 if (section
== NULL
)
2568 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2571 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
2574 _("\nThere is a debug directory in %s, but that section has no contents\n"),
2578 else if (section
->size
< size
)
2581 _("\nError: section %s contains the debug data starting address but it is too small\n"),
2586 fprintf (file
, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2587 section
->name
, (unsigned long) addr
);
2589 dataoff
= addr
- section
->vma
;
2591 if (size
> (section
->size
- dataoff
))
2593 fprintf (file
, _("The debug data size field in the data directory is too big for the section"));
2598 _("Type Size Rva Offset\n"));
2600 /* Read the whole section. */
2601 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2607 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2609 const char *type_name
;
2610 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2611 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2612 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2614 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2616 if ((idd
.Type
) >= IMAGE_NUMBEROF_DEBUG_TYPES
)
2617 type_name
= debug_type_names
[0];
2619 type_name
= debug_type_names
[idd
.Type
];
2621 fprintf (file
, " %2ld %14s %08lx %08lx %08lx\n",
2622 idd
.Type
, type_name
, idd
.SizeOfData
,
2623 idd
.AddressOfRawData
, idd
.PointerToRawData
);
2625 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_CODEVIEW
)
2627 char signature
[CV_INFO_SIGNATURE_LENGTH
* 2 + 1];
2628 /* PR 17512: file: 065-29434-0.001:0.1
2629 We need to use a 32-bit aligned buffer
2630 to safely read in a codeview record. */
2631 char buffer
[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO
);
2634 CODEVIEW_INFO
*cvinfo
= (CODEVIEW_INFO
*) buffer
;
2636 /* The debug entry doesn't have to have to be in a section,
2637 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2638 if (!_bfd_XXi_slurp_codeview_record (abfd
, (file_ptr
) idd
.PointerToRawData
,
2639 idd
.SizeOfData
, cvinfo
, &pdb
))
2642 for (j
= 0; j
< cvinfo
->SignatureLength
; j
++)
2643 sprintf (&signature
[j
*2], "%02x", cvinfo
->Signature
[j
] & 0xff);
2645 /* xgettext:c-format */
2646 fprintf (file
, _("(format %c%c%c%c signature %s age %ld pdb %s)\n"),
2647 buffer
[0], buffer
[1], buffer
[2], buffer
[3],
2648 signature
, cvinfo
->Age
, pdb
[0] ? pdb
: "(none)");
2656 if (size
% sizeof (struct external_IMAGE_DEBUG_DIRECTORY
) != 0)
2658 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2664 pe_is_repro (bfd
* abfd
)
2666 pe_data_type
*pe
= pe_data (abfd
);
2667 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2670 bfd_size_type dataoff
;
2674 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2675 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2680 addr
+= extra
->ImageBase
;
2681 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2683 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2687 if ((section
== NULL
)
2688 || (!(section
->flags
& SEC_HAS_CONTENTS
))
2689 || (section
->size
< size
))
2694 dataoff
= addr
- section
->vma
;
2696 if (size
> (section
->size
- dataoff
))
2701 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2707 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2709 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2710 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2711 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2713 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2715 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_REPRO
)
2727 /* Print out the program headers. */
2730 _bfd_XX_print_private_bfd_data_common (bfd
* abfd
, void * vfile
)
2732 FILE *file
= (FILE *) vfile
;
2734 pe_data_type
*pe
= pe_data (abfd
);
2735 struct internal_extra_pe_aouthdr
*i
= &pe
->pe_opthdr
;
2736 const char *subsystem_name
= NULL
;
2739 /* The MS dumpbin program reportedly ands with 0xff0f before
2740 printing the characteristics field. Not sure why. No reason to
2742 fprintf (file
, _("\nCharacteristics 0x%x\n"), pe
->real_flags
);
2744 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2745 PF (IMAGE_FILE_RELOCS_STRIPPED
, "relocations stripped");
2746 PF (IMAGE_FILE_EXECUTABLE_IMAGE
, "executable");
2747 PF (IMAGE_FILE_LINE_NUMS_STRIPPED
, "line numbers stripped");
2748 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED
, "symbols stripped");
2749 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE
, "large address aware");
2750 PF (IMAGE_FILE_BYTES_REVERSED_LO
, "little endian");
2751 PF (IMAGE_FILE_32BIT_MACHINE
, "32 bit words");
2752 PF (IMAGE_FILE_DEBUG_STRIPPED
, "debugging information removed");
2753 PF (IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP
, "copy to swap file if on removable media");
2754 PF (IMAGE_FILE_NET_RUN_FROM_SWAP
, "copy to swap file if on network media");
2755 PF (IMAGE_FILE_SYSTEM
, "system file");
2756 PF (IMAGE_FILE_DLL
, "DLL");
2757 PF (IMAGE_FILE_UP_SYSTEM_ONLY
, "run only on uniprocessor machine");
2758 PF (IMAGE_FILE_BYTES_REVERSED_HI
, "big endian");
2762 If a PE_IMAGE_DEBUG_TYPE_REPRO entry is present in the debug directory, the
2763 timestamp is to be interpreted as the hash of a reproducible build.
2765 if (pe_is_repro (abfd
))
2767 fprintf (file
, "\nTime/Date\t\t%08lx", pe
->coff
.timestamp
);
2768 fprintf (file
, "\t(This is a reproducible build file hash, not a timestamp)\n");
2772 /* ctime implies '\n'. */
2773 time_t t
= pe
->coff
.timestamp
;
2774 fprintf (file
, "\nTime/Date\t\t%s", ctime (&t
));
2777 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2778 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2780 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2781 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2783 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2784 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2789 case IMAGE_NT_OPTIONAL_HDR_MAGIC
:
2792 case IMAGE_NT_OPTIONAL_HDR64_MAGIC
:
2795 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC
:
2802 fprintf (file
, "Magic\t\t\t%04x", i
->Magic
);
2804 fprintf (file
, "\t(%s)",name
);
2805 fprintf (file
, "\nMajorLinkerVersion\t%d\n", i
->MajorLinkerVersion
);
2806 fprintf (file
, "MinorLinkerVersion\t%d\n", i
->MinorLinkerVersion
);
2807 fprintf (file
, "SizeOfCode\t\t");
2808 bfd_fprintf_vma (abfd
, file
, i
->SizeOfCode
);
2809 fprintf (file
, "\nSizeOfInitializedData\t");
2810 bfd_fprintf_vma (abfd
, file
, i
->SizeOfInitializedData
);
2811 fprintf (file
, "\nSizeOfUninitializedData\t");
2812 bfd_fprintf_vma (abfd
, file
, i
->SizeOfUninitializedData
);
2813 fprintf (file
, "\nAddressOfEntryPoint\t");
2814 bfd_fprintf_vma (abfd
, file
, i
->AddressOfEntryPoint
);
2815 fprintf (file
, "\nBaseOfCode\t\t");
2816 bfd_fprintf_vma (abfd
, file
, i
->BaseOfCode
);
2817 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
2818 /* PE32+ does not have BaseOfData member! */
2819 fprintf (file
, "\nBaseOfData\t\t");
2820 bfd_fprintf_vma (abfd
, file
, i
->BaseOfData
);
2823 fprintf (file
, "\nImageBase\t\t");
2824 bfd_fprintf_vma (abfd
, file
, i
->ImageBase
);
2825 fprintf (file
, "\nSectionAlignment\t%08x\n", i
->SectionAlignment
);
2826 fprintf (file
, "FileAlignment\t\t%08x\n", i
->FileAlignment
);
2827 fprintf (file
, "MajorOSystemVersion\t%d\n", i
->MajorOperatingSystemVersion
);
2828 fprintf (file
, "MinorOSystemVersion\t%d\n", i
->MinorOperatingSystemVersion
);
2829 fprintf (file
, "MajorImageVersion\t%d\n", i
->MajorImageVersion
);
2830 fprintf (file
, "MinorImageVersion\t%d\n", i
->MinorImageVersion
);
2831 fprintf (file
, "MajorSubsystemVersion\t%d\n", i
->MajorSubsystemVersion
);
2832 fprintf (file
, "MinorSubsystemVersion\t%d\n", i
->MinorSubsystemVersion
);
2833 fprintf (file
, "Win32Version\t\t%08x\n", i
->Reserved1
);
2834 fprintf (file
, "SizeOfImage\t\t%08x\n", i
->SizeOfImage
);
2835 fprintf (file
, "SizeOfHeaders\t\t%08x\n", i
->SizeOfHeaders
);
2836 fprintf (file
, "CheckSum\t\t%08x\n", i
->CheckSum
);
2838 switch (i
->Subsystem
)
2840 case IMAGE_SUBSYSTEM_UNKNOWN
:
2841 subsystem_name
= "unspecified";
2843 case IMAGE_SUBSYSTEM_NATIVE
:
2844 subsystem_name
= "NT native";
2846 case IMAGE_SUBSYSTEM_WINDOWS_GUI
:
2847 subsystem_name
= "Windows GUI";
2849 case IMAGE_SUBSYSTEM_WINDOWS_CUI
:
2850 subsystem_name
= "Windows CUI";
2852 case IMAGE_SUBSYSTEM_POSIX_CUI
:
2853 subsystem_name
= "POSIX CUI";
2855 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI
:
2856 subsystem_name
= "Wince CUI";
2858 /* These are from UEFI Platform Initialization Specification 1.1. */
2859 case IMAGE_SUBSYSTEM_EFI_APPLICATION
:
2860 subsystem_name
= "EFI application";
2862 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
:
2863 subsystem_name
= "EFI boot service driver";
2865 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
:
2866 subsystem_name
= "EFI runtime driver";
2868 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER
:
2869 subsystem_name
= "SAL runtime driver";
2871 /* This is from revision 8.0 of the MS PE/COFF spec */
2872 case IMAGE_SUBSYSTEM_XBOX
:
2873 subsystem_name
= "XBOX";
2875 /* Added default case for clarity - subsystem_name is NULL anyway. */
2877 subsystem_name
= NULL
;
2880 fprintf (file
, "Subsystem\t\t%08x", i
->Subsystem
);
2882 fprintf (file
, "\t(%s)", subsystem_name
);
2883 fprintf (file
, "\nDllCharacteristics\t%08x\n", i
->DllCharacteristics
);
2884 if (i
->DllCharacteristics
)
2886 unsigned short dllch
= i
->DllCharacteristics
;
2887 const char *indent
= "\t\t\t\t\t";
2889 if (dllch
& IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA
)
2890 fprintf (file
, "%sHIGH_ENTROPY_VA\n", indent
);
2891 if (dllch
& IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE
)
2892 fprintf (file
, "%sDYNAMIC_BASE\n", indent
);
2893 if (dllch
& IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY
)
2894 fprintf (file
, "%sFORCE_INTEGRITY\n", indent
);
2895 if (dllch
& IMAGE_DLL_CHARACTERISTICS_NX_COMPAT
)
2896 fprintf (file
, "%sNX_COMPAT\n", indent
);
2897 if (dllch
& IMAGE_DLLCHARACTERISTICS_NO_ISOLATION
)
2898 fprintf (file
, "%sNO_ISOLATION\n", indent
);
2899 if (dllch
& IMAGE_DLLCHARACTERISTICS_NO_SEH
)
2900 fprintf (file
, "%sNO_SEH\n", indent
);
2901 if (dllch
& IMAGE_DLLCHARACTERISTICS_NO_BIND
)
2902 fprintf (file
, "%sNO_BIND\n", indent
);
2903 if (dllch
& IMAGE_DLLCHARACTERISTICS_APPCONTAINER
)
2904 fprintf (file
, "%sAPPCONTAINER\n", indent
);
2905 if (dllch
& IMAGE_DLLCHARACTERISTICS_WDM_DRIVER
)
2906 fprintf (file
, "%sWDM_DRIVER\n", indent
);
2907 if (dllch
& IMAGE_DLLCHARACTERISTICS_GUARD_CF
)
2908 fprintf (file
, "%sGUARD_CF\n", indent
);
2909 if (dllch
& IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE
)
2910 fprintf (file
, "%sTERMINAL_SERVICE_AWARE\n", indent
);
2912 fprintf (file
, "SizeOfStackReserve\t");
2913 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackReserve
);
2914 fprintf (file
, "\nSizeOfStackCommit\t");
2915 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackCommit
);
2916 fprintf (file
, "\nSizeOfHeapReserve\t");
2917 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapReserve
);
2918 fprintf (file
, "\nSizeOfHeapCommit\t");
2919 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapCommit
);
2920 fprintf (file
, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i
->LoaderFlags
);
2921 fprintf (file
, "NumberOfRvaAndSizes\t%08lx\n",
2922 (unsigned long) i
->NumberOfRvaAndSizes
);
2924 fprintf (file
, "\nThe Data Directory\n");
2925 for (j
= 0; j
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; j
++)
2927 fprintf (file
, "Entry %1x ", j
);
2928 bfd_fprintf_vma (abfd
, file
, i
->DataDirectory
[j
].VirtualAddress
);
2929 fprintf (file
, " %08lx ", (unsigned long) i
->DataDirectory
[j
].Size
);
2930 fprintf (file
, "%s\n", dir_names
[j
]);
2933 pe_print_idata (abfd
, vfile
);
2934 pe_print_edata (abfd
, vfile
);
2935 if (bfd_coff_have_print_pdata (abfd
))
2936 bfd_coff_print_pdata (abfd
, vfile
);
2938 pe_print_pdata (abfd
, vfile
);
2939 pe_print_reloc (abfd
, vfile
);
2940 pe_print_debugdata (abfd
, file
);
2942 rsrc_print_section (abfd
, vfile
);
2948 is_vma_in_section (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sect
, void *obj
)
2950 bfd_vma addr
= * (bfd_vma
*) obj
;
2951 return (addr
>= sect
->vma
) && (addr
< (sect
->vma
+ sect
->size
));
2955 find_section_by_vma (bfd
*abfd
, bfd_vma addr
)
2957 return bfd_sections_find_if (abfd
, is_vma_in_section
, (void *) & addr
);
2960 /* Copy any private info we understand from the input bfd
2961 to the output bfd. */
2964 _bfd_XX_bfd_copy_private_bfd_data_common (bfd
* ibfd
, bfd
* obfd
)
2966 pe_data_type
*ipe
, *ope
;
2969 /* One day we may try to grok other private data. */
2970 if (ibfd
->xvec
->flavour
!= bfd_target_coff_flavour
2971 || obfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
2974 ipe
= pe_data (ibfd
);
2975 ope
= pe_data (obfd
);
2977 /* pe_opthdr is copied in copy_object. */
2978 ope
->dll
= ipe
->dll
;
2980 /* Don't copy input subsystem if output is different from input. */
2981 if (obfd
->xvec
!= ibfd
->xvec
)
2982 ope
->pe_opthdr
.Subsystem
= IMAGE_SUBSYSTEM_UNKNOWN
;
2984 /* For strip: if we removed .reloc, we'll make a real mess of things
2985 if we don't remove this entry as well. */
2986 if (! pe_data (obfd
)->has_reloc_section
)
2988 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].VirtualAddress
= 0;
2989 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].Size
= 0;
2992 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2993 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2995 if (! pe_data (ibfd
)->has_reloc_section
2996 && ! (pe_data (ibfd
)->real_flags
& IMAGE_FILE_RELOCS_STRIPPED
))
2997 pe_data (obfd
)->dont_strip_reloc
= 1;
2999 memcpy (ope
->dos_message
, ipe
->dos_message
, sizeof (ope
->dos_message
));
3001 /* The file offsets contained in the debug directory need rewriting. */
3002 size
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
;
3005 bfd_vma addr
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
3006 + ope
->pe_opthdr
.ImageBase
;
3007 /* In particular a .buildid section may overlap (in VA space) with
3008 whatever section comes ahead of it (largely because of section->size
3009 representing s_size, not virt_size). Therefore don't look for the
3010 section containing the first byte, but for that covering the last
3012 bfd_vma last
= addr
+ size
- 1;
3013 asection
*section
= find_section_by_vma (obfd
, last
);
3015 if (section
!= NULL
)
3018 bfd_vma dataoff
= addr
- section
->vma
;
3020 /* PR 17512: file: 0f15796a. */
3021 if (addr
< section
->vma
3022 || section
->size
< dataoff
3023 || section
->size
- dataoff
< size
)
3025 /* xgettext:c-format */
3027 (_("%pB: Data Directory (%lx bytes at %" PRIx64
") "
3028 "extends across section boundary at %" PRIx64
),
3029 obfd
, ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
,
3030 (uint64_t) addr
, (uint64_t) section
->vma
);
3034 if ((section
->flags
& SEC_HAS_CONTENTS
) != 0
3035 && bfd_malloc_and_get_section (obfd
, section
, &data
))
3038 struct external_IMAGE_DEBUG_DIRECTORY
*dd
=
3039 (struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
);
3041 for (i
= 0; i
< ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
3042 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
3044 asection
*ddsection
;
3045 struct external_IMAGE_DEBUG_DIRECTORY
*edd
= &(dd
[i
]);
3046 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
3049 _bfd_XXi_swap_debugdir_in (obfd
, edd
, &idd
);
3051 /* RVA 0 means only offset is valid, not handled yet. */
3052 if (idd
.AddressOfRawData
== 0)
3055 idd_vma
= idd
.AddressOfRawData
+ ope
->pe_opthdr
.ImageBase
;
3056 ddsection
= find_section_by_vma (obfd
, idd_vma
);
3058 continue; /* Not in a section! */
3060 idd
.PointerToRawData
3061 = ddsection
->filepos
+ idd_vma
- ddsection
->vma
;
3062 _bfd_XXi_swap_debugdir_out (obfd
, &idd
, edd
);
3065 if (!bfd_set_section_contents (obfd
, section
, data
, 0,
3068 _bfd_error_handler (_("failed to update file offsets"
3069 " in debug directory"));
3077 _bfd_error_handler (_("%pB: failed to read "
3078 "debug data section"), obfd
);
3087 /* Copy private section data. */
3090 _bfd_XX_bfd_copy_private_section_data (bfd
*ibfd
,
3095 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
3096 || bfd_get_flavour (obfd
) != bfd_target_coff_flavour
)
3099 if (coff_section_data (ibfd
, isec
) != NULL
3100 && pei_section_data (ibfd
, isec
) != NULL
)
3102 if (coff_section_data (obfd
, osec
) == NULL
)
3104 size_t amt
= sizeof (struct coff_section_tdata
);
3105 osec
->used_by_bfd
= bfd_zalloc (obfd
, amt
);
3106 if (osec
->used_by_bfd
== NULL
)
3110 if (pei_section_data (obfd
, osec
) == NULL
)
3112 size_t amt
= sizeof (struct pei_section_tdata
);
3113 coff_section_data (obfd
, osec
)->tdata
= bfd_zalloc (obfd
, amt
);
3114 if (coff_section_data (obfd
, osec
)->tdata
== NULL
)
3118 pei_section_data (obfd
, osec
)->virt_size
=
3119 pei_section_data (ibfd
, isec
)->virt_size
;
3120 pei_section_data (obfd
, osec
)->pe_flags
=
3121 pei_section_data (ibfd
, isec
)->pe_flags
;
3128 _bfd_XX_get_symbol_info (bfd
* abfd
, asymbol
*symbol
, symbol_info
*ret
)
3130 coff_get_symbol_info (abfd
, symbol
, ret
);
3133 #if !defined(COFF_WITH_pep) && (defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64))
3135 sort_x64_pdata (const void *l
, const void *r
)
3137 const char *lp
= (const char *) l
;
3138 const char *rp
= (const char *) r
;
3140 vl
= bfd_getl32 (lp
); vr
= bfd_getl32 (rp
);
3142 return (vl
< vr
? -1 : 1);
3143 /* We compare just begin address. */
3148 /* Functions to process a .rsrc section. */
3150 static unsigned int sizeof_leaves
;
3151 static unsigned int sizeof_strings
;
3152 static unsigned int sizeof_tables_and_entries
;
3155 rsrc_count_directory (bfd
*, bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
3158 rsrc_count_entries (bfd
*abfd
,
3160 bfd_byte
*datastart
,
3165 unsigned long entry
, addr
, size
;
3167 if (data
+ 8 >= dataend
)
3174 entry
= (long) bfd_get_32 (abfd
, data
);
3176 if (HighBitSet (entry
))
3177 name
= datastart
+ WithoutHighBit (entry
);
3179 name
= datastart
+ entry
- rva_bias
;
3181 if (name
+ 2 >= dataend
|| name
< datastart
)
3184 unsigned int len
= bfd_get_16 (abfd
, name
);
3185 if (len
== 0 || len
> 256)
3189 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
3191 if (HighBitSet (entry
))
3193 data
= datastart
+ WithoutHighBit (entry
);
3195 if (data
<= datastart
|| data
>= dataend
)
3198 return rsrc_count_directory (abfd
, datastart
, data
, dataend
, rva_bias
);
3201 if (datastart
+ entry
+ 16 >= dataend
)
3204 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
);
3205 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4);
3207 return datastart
+ addr
- rva_bias
+ size
;
3211 rsrc_count_directory (bfd
* abfd
,
3212 bfd_byte
* datastart
,
3217 unsigned int num_entries
, num_ids
;
3218 bfd_byte
* highest_data
= data
;
3220 if (data
+ 16 >= dataend
)
3223 num_entries
= (int) bfd_get_16 (abfd
, data
+ 12);
3224 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14);
3226 num_entries
+= num_ids
;
3230 while (num_entries
--)
3232 bfd_byte
* entry_end
;
3234 entry_end
= rsrc_count_entries (abfd
, num_entries
>= num_ids
,
3235 datastart
, data
, dataend
, rva_bias
);
3237 highest_data
= max (highest_data
, entry_end
);
3238 if (entry_end
>= dataend
)
3242 return max (highest_data
, data
);
3245 typedef struct rsrc_dir_chain
3247 unsigned int num_entries
;
3248 struct rsrc_entry
* first_entry
;
3249 struct rsrc_entry
* last_entry
;
3252 typedef struct rsrc_directory
3254 unsigned int characteristics
;
3259 rsrc_dir_chain names
;
3262 struct rsrc_entry
* entry
;
3265 typedef struct rsrc_string
3271 typedef struct rsrc_leaf
3274 unsigned int codepage
;
3278 typedef struct rsrc_entry
3284 struct rsrc_string name
;
3290 struct rsrc_directory
* directory
;
3291 struct rsrc_leaf
* leaf
;
3294 struct rsrc_entry
* next_entry
;
3295 struct rsrc_directory
* parent
;
3299 rsrc_parse_directory (bfd
*, rsrc_directory
*, bfd_byte
*,
3300 bfd_byte
*, bfd_byte
*, bfd_vma
, rsrc_entry
*);
3303 rsrc_parse_entry (bfd
*abfd
,
3306 bfd_byte
*datastart
,
3310 rsrc_directory
*parent
)
3312 unsigned long val
, addr
, size
;
3314 val
= bfd_get_32 (abfd
, data
);
3316 entry
->parent
= parent
;
3317 entry
->is_name
= is_name
;
3323 if (HighBitSet (val
))
3325 val
= WithoutHighBit (val
);
3327 address
= datastart
+ val
;
3331 address
= datastart
+ val
- rva_bias
;
3334 if (address
+ 3 > dataend
)
3337 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, address
);
3338 entry
->name_id
.name
.string
= address
+ 2;
3341 entry
->name_id
.id
= val
;
3343 val
= bfd_get_32 (abfd
, data
+ 4);
3345 if (HighBitSet (val
))
3347 entry
->is_dir
= true;
3348 entry
->value
.directory
= bfd_malloc (sizeof (*entry
->value
.directory
));
3349 if (entry
->value
.directory
== NULL
)
3352 return rsrc_parse_directory (abfd
, entry
->value
.directory
,
3354 datastart
+ WithoutHighBit (val
),
3355 dataend
, rva_bias
, entry
);
3358 entry
->is_dir
= false;
3359 entry
->value
.leaf
= bfd_malloc (sizeof (*entry
->value
.leaf
));
3360 if (entry
->value
.leaf
== NULL
)
3363 data
= datastart
+ val
;
3364 if (data
< datastart
|| data
+ 12 > dataend
)
3367 addr
= bfd_get_32 (abfd
, data
);
3368 size
= entry
->value
.leaf
->size
= bfd_get_32 (abfd
, data
+ 4);
3369 entry
->value
.leaf
->codepage
= bfd_get_32 (abfd
, data
+ 8);
3370 /* FIXME: We assume that the reserved field (data + 12) is OK. */
3372 if (size
> dataend
- datastart
- (addr
- rva_bias
))
3374 entry
->value
.leaf
->data
= bfd_malloc (size
);
3375 if (entry
->value
.leaf
->data
== NULL
)
3378 memcpy (entry
->value
.leaf
->data
, datastart
+ addr
- rva_bias
, size
);
3379 return datastart
+ (addr
- rva_bias
) + size
;
3383 rsrc_parse_entries (bfd
*abfd
,
3384 rsrc_dir_chain
*chain
,
3386 bfd_byte
*highest_data
,
3387 bfd_byte
*datastart
,
3391 rsrc_directory
*parent
)
3396 if (chain
->num_entries
== 0)
3398 chain
->first_entry
= chain
->last_entry
= NULL
;
3399 return highest_data
;
3402 entry
= bfd_malloc (sizeof (*entry
));
3406 chain
->first_entry
= entry
;
3408 for (i
= chain
->num_entries
; i
--;)
3410 bfd_byte
* entry_end
;
3412 entry_end
= rsrc_parse_entry (abfd
, is_name
, entry
, datastart
,
3413 data
, dataend
, rva_bias
, parent
);
3415 highest_data
= max (entry_end
, highest_data
);
3416 if (entry_end
> dataend
)
3421 entry
->next_entry
= bfd_malloc (sizeof (*entry
));
3422 entry
= entry
->next_entry
;
3427 entry
->next_entry
= NULL
;
3430 chain
->last_entry
= entry
;
3432 return highest_data
;
3436 rsrc_parse_directory (bfd
* abfd
,
3437 rsrc_directory
* table
,
3438 bfd_byte
* datastart
,
3444 bfd_byte
* highest_data
= data
;
3449 table
->characteristics
= bfd_get_32 (abfd
, data
);
3450 table
->time
= bfd_get_32 (abfd
, data
+ 4);
3451 table
->major
= bfd_get_16 (abfd
, data
+ 8);
3452 table
->minor
= bfd_get_16 (abfd
, data
+ 10);
3453 table
->names
.num_entries
= bfd_get_16 (abfd
, data
+ 12);
3454 table
->ids
.num_entries
= bfd_get_16 (abfd
, data
+ 14);
3455 table
->entry
= entry
;
3459 highest_data
= rsrc_parse_entries (abfd
, & table
->names
, true, data
,
3460 datastart
, data
, dataend
, rva_bias
, table
);
3461 data
+= table
->names
.num_entries
* 8;
3463 highest_data
= rsrc_parse_entries (abfd
, & table
->ids
, false, highest_data
,
3464 datastart
, data
, dataend
, rva_bias
, table
);
3465 data
+= table
->ids
.num_entries
* 8;
3467 return max (highest_data
, data
);
3470 typedef struct rsrc_write_data
3473 bfd_byte
* datastart
;
3474 bfd_byte
* next_table
;
3475 bfd_byte
* next_leaf
;
3476 bfd_byte
* next_string
;
3477 bfd_byte
* next_data
;
3482 rsrc_write_string (rsrc_write_data
* data
,
3483 rsrc_string
* string
)
3485 bfd_put_16 (data
->abfd
, string
->len
, data
->next_string
);
3486 memcpy (data
->next_string
+ 2, string
->string
, string
->len
* 2);
3487 data
->next_string
+= (string
->len
+ 1) * 2;
3490 static inline unsigned int
3491 rsrc_compute_rva (rsrc_write_data
* data
,
3494 return (addr
- data
->datastart
) + data
->rva_bias
;
3498 rsrc_write_leaf (rsrc_write_data
* data
,
3501 bfd_put_32 (data
->abfd
, rsrc_compute_rva (data
, data
->next_data
),
3503 bfd_put_32 (data
->abfd
, leaf
->size
, data
->next_leaf
+ 4);
3504 bfd_put_32 (data
->abfd
, leaf
->codepage
, data
->next_leaf
+ 8);
3505 bfd_put_32 (data
->abfd
, 0 /*reserved*/, data
->next_leaf
+ 12);
3506 data
->next_leaf
+= 16;
3508 memcpy (data
->next_data
, leaf
->data
, leaf
->size
);
3509 /* An undocumented feature of Windows resources is that each unit
3510 of raw data is 8-byte aligned... */
3511 data
->next_data
+= ((leaf
->size
+ 7) & ~7);
3514 static void rsrc_write_directory (rsrc_write_data
*, rsrc_directory
*);
3517 rsrc_write_entry (rsrc_write_data
* data
,
3523 bfd_put_32 (data
->abfd
,
3524 SetHighBit (data
->next_string
- data
->datastart
),
3526 rsrc_write_string (data
, & entry
->name_id
.name
);
3529 bfd_put_32 (data
->abfd
, entry
->name_id
.id
, where
);
3533 bfd_put_32 (data
->abfd
,
3534 SetHighBit (data
->next_table
- data
->datastart
),
3536 rsrc_write_directory (data
, entry
->value
.directory
);
3540 bfd_put_32 (data
->abfd
, data
->next_leaf
- data
->datastart
, where
+ 4);
3541 rsrc_write_leaf (data
, entry
->value
.leaf
);
3546 rsrc_compute_region_sizes (rsrc_directory
* dir
)
3548 struct rsrc_entry
* entry
;
3553 sizeof_tables_and_entries
+= 16;
3555 for (entry
= dir
->names
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3557 sizeof_tables_and_entries
+= 8;
3559 sizeof_strings
+= (entry
->name_id
.name
.len
+ 1) * 2;
3562 rsrc_compute_region_sizes (entry
->value
.directory
);
3564 sizeof_leaves
+= 16;
3567 for (entry
= dir
->ids
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3569 sizeof_tables_and_entries
+= 8;
3572 rsrc_compute_region_sizes (entry
->value
.directory
);
3574 sizeof_leaves
+= 16;
3579 rsrc_write_directory (rsrc_write_data
* data
,
3580 rsrc_directory
* dir
)
3584 bfd_byte
* next_entry
;
3587 bfd_put_32 (data
->abfd
, dir
->characteristics
, data
->next_table
);
3588 bfd_put_32 (data
->abfd
, 0 /*dir->time*/, data
->next_table
+ 4);
3589 bfd_put_16 (data
->abfd
, dir
->major
, data
->next_table
+ 8);
3590 bfd_put_16 (data
->abfd
, dir
->minor
, data
->next_table
+ 10);
3591 bfd_put_16 (data
->abfd
, dir
->names
.num_entries
, data
->next_table
+ 12);
3592 bfd_put_16 (data
->abfd
, dir
->ids
.num_entries
, data
->next_table
+ 14);
3594 /* Compute where the entries and the next table will be placed. */
3595 next_entry
= data
->next_table
+ 16;
3596 data
->next_table
= next_entry
+ (dir
->names
.num_entries
* 8)
3597 + (dir
->ids
.num_entries
* 8);
3598 nt
= data
->next_table
;
3600 /* Write the entries. */
3601 for (i
= dir
->names
.num_entries
, entry
= dir
->names
.first_entry
;
3602 i
> 0 && entry
!= NULL
;
3603 i
--, entry
= entry
->next_entry
)
3605 BFD_ASSERT (entry
->is_name
);
3606 rsrc_write_entry (data
, next_entry
, entry
);
3609 BFD_ASSERT (i
== 0);
3610 BFD_ASSERT (entry
== NULL
);
3612 for (i
= dir
->ids
.num_entries
, entry
= dir
->ids
.first_entry
;
3613 i
> 0 && entry
!= NULL
;
3614 i
--, entry
= entry
->next_entry
)
3616 BFD_ASSERT (! entry
->is_name
);
3617 rsrc_write_entry (data
, next_entry
, entry
);
3620 BFD_ASSERT (i
== 0);
3621 BFD_ASSERT (entry
== NULL
);
3622 BFD_ASSERT (nt
== next_entry
);
3625 #if ! defined __CYGWIN__ && ! defined __MINGW32__
3626 /* Return the length (number of units) of the first character in S,
3627 putting its 'ucs4_t' representation in *PUC. */
3630 u16_mbtouc (wint_t * puc
, const unsigned short * s
, unsigned int n
)
3632 unsigned short c
= * s
;
3634 if (c
< 0xd800 || c
>= 0xe000)
3644 if (s
[1] >= 0xdc00 && s
[1] < 0xe000)
3646 *puc
= 0x10000 + ((c
- 0xd800) << 10) + (s
[1] - 0xdc00);
3652 /* Incomplete multibyte character. */
3658 /* Invalid multibyte character. */
3662 #endif /* not Cygwin/Mingw */
3664 /* Perform a comparison of two entries. */
3666 rsrc_cmp (bool is_name
, rsrc_entry
* a
, rsrc_entry
* b
)
3675 return a
->name_id
.id
- b
->name_id
.id
;
3677 /* We have to perform a case insenstive, unicode string comparison... */
3678 astring
= a
->name_id
.name
.string
;
3679 alen
= a
->name_id
.name
.len
;
3680 bstring
= b
->name_id
.name
.string
;
3681 blen
= b
->name_id
.name
.len
;
3683 #if defined __CYGWIN__ || defined __MINGW32__
3684 /* Under Windows hosts (both Cygwin and Mingw types),
3685 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3686 function however goes by different names in the two environments... */
3690 #define rscpcmp wcsncasecmp
3693 #define rscpcmp wcsnicmp
3696 res
= rscpcmp ((const wchar_t *) astring
, (const wchar_t *) bstring
,
3704 for (i
= min (alen
, blen
); i
--; astring
+= 2, bstring
+= 2)
3709 /* Convert UTF-16 unicode characters into wchar_t characters
3710 so that we can then perform a case insensitive comparison. */
3711 unsigned int Alen
= u16_mbtouc (& awc
, (const unsigned short *) astring
, 2);
3712 unsigned int Blen
= u16_mbtouc (& bwc
, (const unsigned short *) bstring
, 2);
3717 awc
= towlower (awc
);
3718 bwc
= towlower (bwc
);
3734 rsrc_print_name (char * buffer
, rsrc_string string
)
3737 bfd_byte
* name
= string
.string
;
3739 for (i
= string
.len
; i
--; name
+= 2)
3740 sprintf (buffer
+ strlen (buffer
), "%.1s", name
);
3744 rsrc_resource_name (rsrc_entry
*entry
, rsrc_directory
*dir
, char *buffer
)
3746 bool is_string
= false;
3750 if (dir
!= NULL
&& dir
->entry
!= NULL
&& dir
->entry
->parent
!= NULL
3751 && dir
->entry
->parent
->entry
!= NULL
)
3753 strcpy (buffer
, "type: ");
3754 if (dir
->entry
->parent
->entry
->is_name
)
3755 rsrc_print_name (buffer
+ strlen (buffer
),
3756 dir
->entry
->parent
->entry
->name_id
.name
);
3759 unsigned int id
= dir
->entry
->parent
->entry
->name_id
.id
;
3761 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3764 case 1: strcat (buffer
, " (CURSOR)"); break;
3765 case 2: strcat (buffer
, " (BITMAP)"); break;
3766 case 3: strcat (buffer
, " (ICON)"); break;
3767 case 4: strcat (buffer
, " (MENU)"); break;
3768 case 5: strcat (buffer
, " (DIALOG)"); break;
3769 case 6: strcat (buffer
, " (STRING)"); is_string
= true; break;
3770 case 7: strcat (buffer
, " (FONTDIR)"); break;
3771 case 8: strcat (buffer
, " (FONT)"); break;
3772 case 9: strcat (buffer
, " (ACCELERATOR)"); break;
3773 case 10: strcat (buffer
, " (RCDATA)"); break;
3774 case 11: strcat (buffer
, " (MESSAGETABLE)"); break;
3775 case 12: strcat (buffer
, " (GROUP_CURSOR)"); break;
3776 case 14: strcat (buffer
, " (GROUP_ICON)"); break;
3777 case 16: strcat (buffer
, " (VERSION)"); break;
3778 case 17: strcat (buffer
, " (DLGINCLUDE)"); break;
3779 case 19: strcat (buffer
, " (PLUGPLAY)"); break;
3780 case 20: strcat (buffer
, " (VXD)"); break;
3781 case 21: strcat (buffer
, " (ANICURSOR)"); break;
3782 case 22: strcat (buffer
, " (ANIICON)"); break;
3783 case 23: strcat (buffer
, " (HTML)"); break;
3784 case 24: strcat (buffer
, " (MANIFEST)"); break;
3785 case 240: strcat (buffer
, " (DLGINIT)"); break;
3786 case 241: strcat (buffer
, " (TOOLBAR)"); break;
3791 if (dir
!= NULL
&& dir
->entry
!= NULL
)
3793 strcat (buffer
, " name: ");
3794 if (dir
->entry
->is_name
)
3795 rsrc_print_name (buffer
+ strlen (buffer
), dir
->entry
->name_id
.name
);
3798 unsigned int id
= dir
->entry
->name_id
.id
;
3800 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3803 sprintf (buffer
+ strlen (buffer
), " (resource id range: %d - %d)",
3804 (id
- 1) << 4, (id
<< 4) - 1);
3810 strcat (buffer
, " lang: ");
3813 rsrc_print_name (buffer
+ strlen (buffer
), entry
->name_id
.name
);
3815 sprintf (buffer
+ strlen (buffer
), "%x", entry
->name_id
.id
);
3821 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3822 their ID is stored in the NAME entry. The bottom four bits are used as
3823 an index into unicode string table that makes up the data of the leaf.
3824 So identical type-name-lang string resources may not actually be
3827 This function is called when we have detected two string resources with
3828 match top-28-bit IDs. We have to scan the string tables inside the leaves
3829 and discover if there are any real collisions. If there are then we report
3830 them and return FALSE. Otherwise we copy any strings from B into A and
3831 then return TRUE. */
3834 rsrc_merge_string_entries (rsrc_entry
* a ATTRIBUTE_UNUSED
,
3835 rsrc_entry
* b ATTRIBUTE_UNUSED
)
3837 unsigned int copy_needed
= 0;
3841 bfd_byte
* new_data
;
3844 /* Step one: Find out what we have to do. */
3845 BFD_ASSERT (! a
->is_dir
);
3846 astring
= a
->value
.leaf
->data
;
3848 BFD_ASSERT (! b
->is_dir
);
3849 bstring
= b
->value
.leaf
->data
;
3851 for (i
= 0; i
< 16; i
++)
3853 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3854 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3858 copy_needed
+= blen
* 2;
3862 else if (alen
!= blen
)
3863 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3865 /* alen == blen != 0. We might have two identical strings. If so we
3866 can ignore the second one. There is no need for wchar_t vs UTF-16
3867 theatrics here - we are only interested in (case sensitive) equality. */
3868 else if (memcmp (astring
+ 2, bstring
+ 2, alen
* 2) != 0)
3871 astring
+= (alen
+ 1) * 2;
3872 bstring
+= (blen
+ 1) * 2;
3877 if (a
->parent
!= NULL
3878 && a
->parent
->entry
!= NULL
3879 && !a
->parent
->entry
->is_name
)
3880 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3881 ((a
->parent
->entry
->name_id
.id
- 1) << 4) + i
);
3885 if (copy_needed
== 0)
3888 /* If we reach here then A and B must both have non-colliding strings.
3889 (We never get string resources with fully empty string tables).
3890 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3892 new_data
= bfd_malloc (a
->value
.leaf
->size
+ copy_needed
);
3893 if (new_data
== NULL
)
3897 astring
= a
->value
.leaf
->data
;
3898 bstring
= b
->value
.leaf
->data
;
3900 for (i
= 0; i
< 16; i
++)
3902 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3903 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3907 memcpy (nstring
, astring
, (alen
+ 1) * 2);
3908 nstring
+= (alen
+ 1) * 2;
3912 memcpy (nstring
, bstring
, (blen
+ 1) * 2);
3913 nstring
+= (blen
+ 1) * 2;
3921 astring
+= (alen
+ 1) * 2;
3922 bstring
+= (blen
+ 1) * 2;
3925 BFD_ASSERT (nstring
- new_data
== (signed) (a
->value
.leaf
->size
+ copy_needed
));
3927 free (a
->value
.leaf
->data
);
3928 a
->value
.leaf
->data
= new_data
;
3929 a
->value
.leaf
->size
+= copy_needed
;
3934 static void rsrc_merge (rsrc_entry
*, rsrc_entry
*);
3936 /* Sort the entries in given part of the directory.
3937 We use an old fashioned bubble sort because we are dealing
3938 with lists and we want to handle matches specially. */
3941 rsrc_sort_entries (rsrc_dir_chain
*chain
,
3943 rsrc_directory
*dir
)
3947 rsrc_entry
** points_to_entry
;
3950 if (chain
->num_entries
< 2)
3956 points_to_entry
= & chain
->first_entry
;
3957 entry
= * points_to_entry
;
3958 next
= entry
->next_entry
;
3962 signed int cmp
= rsrc_cmp (is_name
, entry
, next
);
3966 entry
->next_entry
= next
->next_entry
;
3967 next
->next_entry
= entry
;
3968 * points_to_entry
= next
;
3969 points_to_entry
= & next
->next_entry
;
3970 next
= entry
->next_entry
;
3975 if (entry
->is_dir
&& next
->is_dir
)
3977 /* When we encounter identical directory entries we have to
3978 merge them together. The exception to this rule is for
3979 resource manifests - there can only be one of these,
3980 even if they differ in language. Zero-language manifests
3981 are assumed to be default manifests (provided by the
3982 Cygwin/MinGW build system) and these can be silently dropped,
3983 unless that would reduce the number of manifests to zero.
3984 There should only ever be one non-zero lang manifest -
3985 if there are more it is an error. A non-zero lang
3986 manifest takes precedence over a default manifest. */
3988 && entry
->name_id
.id
== 1
3990 && dir
->entry
!= NULL
3991 && !dir
->entry
->is_name
3992 && dir
->entry
->name_id
.id
== 0x18)
3994 if (next
->value
.directory
->names
.num_entries
== 0
3995 && next
->value
.directory
->ids
.num_entries
== 1
3996 && !next
->value
.directory
->ids
.first_entry
->is_name
3997 && next
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3998 /* Fall through so that NEXT is dropped. */
4000 else if (entry
->value
.directory
->names
.num_entries
== 0
4001 && entry
->value
.directory
->ids
.num_entries
== 1
4002 && !entry
->value
.directory
->ids
.first_entry
->is_name
4003 && entry
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
4005 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
4006 entry
->next_entry
= next
->next_entry
;
4007 next
->next_entry
= entry
;
4008 * points_to_entry
= next
;
4009 points_to_entry
= & next
->next_entry
;
4010 next
= entry
->next_entry
;
4015 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
4016 bfd_set_error (bfd_error_file_truncated
);
4020 /* Unhook NEXT from the chain. */
4021 /* FIXME: memory loss here. */
4022 entry
->next_entry
= next
->next_entry
;
4023 chain
->num_entries
--;
4024 if (chain
->num_entries
< 2)
4026 next
= next
->next_entry
;
4029 rsrc_merge (entry
, next
);
4031 else if (entry
->is_dir
!= next
->is_dir
)
4033 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
4034 bfd_set_error (bfd_error_file_truncated
);
4039 /* Otherwise with identical leaves we issue an error
4040 message - because there should never be duplicates.
4041 The exception is Type 18/Name 1/Lang 0 which is the
4042 defaul manifest - this can just be dropped. */
4044 && entry
->name_id
.id
== 0
4046 && dir
->entry
!= NULL
4047 && !dir
->entry
->is_name
4048 && dir
->entry
->name_id
.id
== 1
4049 && dir
->entry
->parent
!= NULL
4050 && dir
->entry
->parent
->entry
!= NULL
4051 && !dir
->entry
->parent
->entry
->is_name
4052 && dir
->entry
->parent
->entry
->name_id
.id
== 0x18 /* RT_MANIFEST */)
4054 else if (dir
!= NULL
4055 && dir
->entry
!= NULL
4056 && dir
->entry
->parent
!= NULL
4057 && dir
->entry
->parent
->entry
!= NULL
4058 && !dir
->entry
->parent
->entry
->is_name
4059 && dir
->entry
->parent
->entry
->name_id
.id
== 0x6 /* RT_STRING */)
4061 /* Strings need special handling. */
4062 if (! rsrc_merge_string_entries (entry
, next
))
4064 /* _bfd_error_handler should have been called inside merge_strings. */
4065 bfd_set_error (bfd_error_file_truncated
);
4072 || dir
->entry
== NULL
4073 || dir
->entry
->parent
== NULL
4074 || dir
->entry
->parent
->entry
== NULL
)
4075 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
4080 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
4081 rsrc_resource_name (entry
, dir
, buff
));
4083 bfd_set_error (bfd_error_file_truncated
);
4088 /* Unhook NEXT from the chain. */
4089 entry
->next_entry
= next
->next_entry
;
4090 chain
->num_entries
--;
4091 if (chain
->num_entries
< 2)
4093 next
= next
->next_entry
;
4097 points_to_entry
= & entry
->next_entry
;
4099 next
= next
->next_entry
;
4104 chain
->last_entry
= entry
;
4109 /* Attach B's chain onto A. */
4111 rsrc_attach_chain (rsrc_dir_chain
* achain
, rsrc_dir_chain
* bchain
)
4113 if (bchain
->num_entries
== 0)
4116 achain
->num_entries
+= bchain
->num_entries
;
4118 if (achain
->first_entry
== NULL
)
4120 achain
->first_entry
= bchain
->first_entry
;
4121 achain
->last_entry
= bchain
->last_entry
;
4125 achain
->last_entry
->next_entry
= bchain
->first_entry
;
4126 achain
->last_entry
= bchain
->last_entry
;
4129 bchain
->num_entries
= 0;
4130 bchain
->first_entry
= bchain
->last_entry
= NULL
;
4134 rsrc_merge (struct rsrc_entry
* a
, struct rsrc_entry
* b
)
4136 rsrc_directory
* adir
;
4137 rsrc_directory
* bdir
;
4139 BFD_ASSERT (a
->is_dir
);
4140 BFD_ASSERT (b
->is_dir
);
4142 adir
= a
->value
.directory
;
4143 bdir
= b
->value
.directory
;
4145 if (adir
->characteristics
!= bdir
->characteristics
)
4147 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics"));
4148 bfd_set_error (bfd_error_file_truncated
);
4152 if (adir
->major
!= bdir
->major
|| adir
->minor
!= bdir
->minor
)
4154 _bfd_error_handler (_(".rsrc merge failure: differing directory versions"));
4155 bfd_set_error (bfd_error_file_truncated
);
4159 /* Attach B's name chain to A. */
4160 rsrc_attach_chain (& adir
->names
, & bdir
->names
);
4162 /* Attach B's ID chain to A. */
4163 rsrc_attach_chain (& adir
->ids
, & bdir
->ids
);
4165 /* Now sort A's entries. */
4166 rsrc_sort_entries (& adir
->names
, true, adir
);
4167 rsrc_sort_entries (& adir
->ids
, false, adir
);
4170 /* Check the .rsrc section. If it contains multiple concatenated
4171 resources then we must merge them properly. Otherwise Windows
4172 will ignore all but the first set. */
4175 rsrc_process_section (bfd
* abfd
,
4176 struct coff_final_link_info
* pfinfo
)
4178 rsrc_directory new_table
;
4184 bfd_byte
* datastart
;
4186 bfd_byte
* new_data
;
4187 unsigned int num_resource_sets
;
4188 rsrc_directory
* type_tables
;
4189 rsrc_write_data write_data
;
4192 unsigned int num_input_rsrc
= 0;
4193 unsigned int max_num_input_rsrc
= 4;
4194 ptrdiff_t * rsrc_sizes
= NULL
;
4196 new_table
.names
.num_entries
= 0;
4197 new_table
.ids
.num_entries
= 0;
4199 sec
= bfd_get_section_by_name (abfd
, ".rsrc");
4200 if (sec
== NULL
|| (size
= sec
->rawsize
) == 0)
4203 pe
= pe_data (abfd
);
4207 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4209 if (! bfd_malloc_and_get_section (abfd
, sec
, &datastart
))
4212 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4213 their lengths. Note - we rely upon the fact that the linker script
4214 does *not* sort the input .rsrc sections, so that the order in the
4215 linkinfo list matches the order in the output .rsrc section.
4217 We need to know the lengths because each input .rsrc section has padding
4218 at the end of a variable amount. (It does not appear to be based upon
4219 the section alignment or the file alignment). We need to skip any
4220 padding bytes when parsing the input .rsrc sections. */
4222 rsrc_sizes
= bfd_malloc (max_num_input_rsrc
* sizeof (*rsrc_sizes
));
4223 if (rsrc_sizes
== NULL
)
4226 for (input
= pfinfo
->info
->input_bfds
;
4228 input
= input
->link
.next
)
4230 asection
* rsrc_sec
= bfd_get_section_by_name (input
, ".rsrc");
4232 /* PR 18372 - skip discarded .rsrc sections. */
4233 if (rsrc_sec
!= NULL
&& !discarded_section (rsrc_sec
))
4235 if (num_input_rsrc
== max_num_input_rsrc
)
4237 max_num_input_rsrc
+= 10;
4238 rsrc_sizes
= bfd_realloc (rsrc_sizes
, max_num_input_rsrc
4239 * sizeof (*rsrc_sizes
));
4240 if (rsrc_sizes
== NULL
)
4244 BFD_ASSERT (rsrc_sec
->size
> 0);
4245 rsrc_sizes
[num_input_rsrc
++] = rsrc_sec
->size
;
4249 if (num_input_rsrc
< 2)
4252 /* Step one: Walk the section, computing the size of the tables,
4253 leaves and data and decide if we need to do anything. */
4254 dataend
= data
+ size
;
4255 num_resource_sets
= 0;
4257 while (data
< dataend
)
4259 bfd_byte
* p
= data
;
4261 data
= rsrc_count_directory (abfd
, data
, data
, dataend
, rva_bias
);
4265 /* Corrupted .rsrc section - cannot merge. */
4266 _bfd_error_handler (_("%pB: .rsrc merge failure: corrupt .rsrc section"),
4268 bfd_set_error (bfd_error_file_truncated
);
4272 if ((data
- p
) > rsrc_sizes
[num_resource_sets
])
4274 _bfd_error_handler (_("%pB: .rsrc merge failure: unexpected .rsrc size"),
4276 bfd_set_error (bfd_error_file_truncated
);
4279 /* FIXME: Should we add a check for "data - p" being much smaller
4280 than rsrc_sizes[num_resource_sets] ? */
4282 data
= p
+ rsrc_sizes
[num_resource_sets
];
4283 rva_bias
+= data
- p
;
4284 ++ num_resource_sets
;
4286 BFD_ASSERT (num_resource_sets
== num_input_rsrc
);
4288 /* Step two: Walk the data again, building trees of the resources. */
4290 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4292 type_tables
= bfd_malloc (num_resource_sets
* sizeof (*type_tables
));
4293 if (type_tables
== NULL
)
4297 while (data
< dataend
)
4299 bfd_byte
* p
= data
;
4301 (void) rsrc_parse_directory (abfd
, type_tables
+ indx
, data
, data
,
4302 dataend
, rva_bias
, NULL
);
4303 data
= p
+ rsrc_sizes
[indx
];
4304 rva_bias
+= data
- p
;
4307 BFD_ASSERT (indx
== num_resource_sets
);
4309 /* Step three: Merge the top level tables (there can be only one).
4311 We must ensure that the merged entries are in ascending order.
4313 We also thread the top level table entries from the old tree onto
4314 the new table, so that they can be pulled off later. */
4316 /* FIXME: Should we verify that all type tables are the same ? */
4317 new_table
.characteristics
= type_tables
[0].characteristics
;
4318 new_table
.time
= type_tables
[0].time
;
4319 new_table
.major
= type_tables
[0].major
;
4320 new_table
.minor
= type_tables
[0].minor
;
4322 /* Chain the NAME entries onto the table. */
4323 new_table
.names
.first_entry
= NULL
;
4324 new_table
.names
.last_entry
= NULL
;
4326 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4327 rsrc_attach_chain (& new_table
.names
, & type_tables
[indx
].names
);
4329 rsrc_sort_entries (& new_table
.names
, true, & new_table
);
4331 /* Chain the ID entries onto the table. */
4332 new_table
.ids
.first_entry
= NULL
;
4333 new_table
.ids
.last_entry
= NULL
;
4335 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4336 rsrc_attach_chain (& new_table
.ids
, & type_tables
[indx
].ids
);
4338 rsrc_sort_entries (& new_table
.ids
, false, & new_table
);
4340 /* Step four: Create new contents for the .rsrc section. */
4341 /* Step four point one: Compute the size of each region of the .rsrc section.
4342 We do this now, rather than earlier, as the merging above may have dropped
4344 sizeof_leaves
= sizeof_strings
= sizeof_tables_and_entries
= 0;
4345 rsrc_compute_region_sizes (& new_table
);
4346 /* We increment sizeof_strings to make sure that resource data
4347 starts on an 8-byte boundary. FIXME: Is this correct ? */
4348 sizeof_strings
= (sizeof_strings
+ 7) & ~ 7;
4350 new_data
= bfd_zalloc (abfd
, size
);
4351 if (new_data
== NULL
)
4354 write_data
.abfd
= abfd
;
4355 write_data
.datastart
= new_data
;
4356 write_data
.next_table
= new_data
;
4357 write_data
.next_leaf
= new_data
+ sizeof_tables_and_entries
;
4358 write_data
.next_string
= write_data
.next_leaf
+ sizeof_leaves
;
4359 write_data
.next_data
= write_data
.next_string
+ sizeof_strings
;
4360 write_data
.rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4362 rsrc_write_directory (& write_data
, & new_table
);
4364 /* Step five: Replace the old contents with the new.
4365 We don't recompute the size as it's too late here to shrink section.
4366 See PR ld/20193 for more details. */
4367 bfd_set_section_contents (pfinfo
->output_bfd
, sec
, new_data
, 0, size
);
4368 sec
->size
= sec
->rawsize
= size
;
4371 /* Step six: Free all the memory that we have used. */
4372 /* FIXME: Free the resource tree, if we have one. */
4377 /* Handle the .idata section and other things that need symbol table
4381 _bfd_XXi_final_link_postscript (bfd
* abfd
, struct coff_final_link_info
*pfinfo
)
4383 struct coff_link_hash_entry
*h1
;
4384 struct bfd_link_info
*info
= pfinfo
->info
;
4387 /* There are a few fields that need to be filled in now while we
4388 have symbol table access.
4390 The .idata subsections aren't directly available as sections, but
4391 they are in the symbol table, so get them from there. */
4393 /* The import directory. This is the address of .idata$2, with size
4394 of .idata$2 + .idata$3. */
4395 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4396 ".idata$2", false, false, true);
4399 /* PR ld/2729: We cannot rely upon all the output sections having been
4400 created properly, so check before referencing them. Issue a warning
4401 message for any sections tht could not be found. */
4402 if ((h1
->root
.type
== bfd_link_hash_defined
4403 || h1
->root
.type
== bfd_link_hash_defweak
)
4404 && h1
->root
.u
.def
.section
!= NULL
4405 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4406 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
=
4407 (h1
->root
.u
.def
.value
4408 + h1
->root
.u
.def
.section
->output_section
->vma
4409 + h1
->root
.u
.def
.section
->output_offset
);
4413 (_("%pB: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4418 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4419 ".idata$4", false, false, true);
4421 && (h1
->root
.type
== bfd_link_hash_defined
4422 || h1
->root
.type
== bfd_link_hash_defweak
)
4423 && h1
->root
.u
.def
.section
!= NULL
4424 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4425 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].Size
=
4426 ((h1
->root
.u
.def
.value
4427 + h1
->root
.u
.def
.section
->output_section
->vma
4428 + h1
->root
.u
.def
.section
->output_offset
)
4429 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
);
4433 (_("%pB: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4438 /* The import address table. This is the size/address of
4440 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4441 ".idata$5", false, false, true);
4443 && (h1
->root
.type
== bfd_link_hash_defined
4444 || h1
->root
.type
== bfd_link_hash_defweak
)
4445 && h1
->root
.u
.def
.section
!= NULL
4446 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4447 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4448 (h1
->root
.u
.def
.value
4449 + h1
->root
.u
.def
.section
->output_section
->vma
4450 + h1
->root
.u
.def
.section
->output_offset
);
4454 (_("%pB: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4459 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4460 ".idata$6", false, false, true);
4462 && (h1
->root
.type
== bfd_link_hash_defined
4463 || h1
->root
.type
== bfd_link_hash_defweak
)
4464 && h1
->root
.u
.def
.section
!= NULL
4465 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4466 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4467 ((h1
->root
.u
.def
.value
4468 + h1
->root
.u
.def
.section
->output_section
->vma
4469 + h1
->root
.u
.def
.section
->output_offset
)
4470 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
);
4474 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4481 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4482 "__IAT_start__", false, false, true);
4484 && (h1
->root
.type
== bfd_link_hash_defined
4485 || h1
->root
.type
== bfd_link_hash_defweak
)
4486 && h1
->root
.u
.def
.section
!= NULL
4487 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4492 (h1
->root
.u
.def
.value
4493 + h1
->root
.u
.def
.section
->output_section
->vma
4494 + h1
->root
.u
.def
.section
->output_offset
);
4496 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4497 "__IAT_end__", false, false, true);
4499 && (h1
->root
.type
== bfd_link_hash_defined
4500 || h1
->root
.type
== bfd_link_hash_defweak
)
4501 && h1
->root
.u
.def
.section
!= NULL
4502 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4504 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4505 ((h1
->root
.u
.def
.value
4506 + h1
->root
.u
.def
.section
->output_section
->vma
4507 + h1
->root
.u
.def
.section
->output_offset
)
4509 if (pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
!= 0)
4510 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4511 iat_va
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
4516 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4517 " because .idata$6 is missing"), abfd
);
4523 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4524 (bfd_get_symbol_leading_char (abfd
) != 0
4525 ? "__tls_used" : "_tls_used"),
4526 false, false, true);
4529 if ((h1
->root
.type
== bfd_link_hash_defined
4530 || h1
->root
.type
== bfd_link_hash_defweak
)
4531 && h1
->root
.u
.def
.section
!= NULL
4532 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4533 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].VirtualAddress
=
4534 (h1
->root
.u
.def
.value
4535 + h1
->root
.u
.def
.section
->output_section
->vma
4536 + h1
->root
.u
.def
.section
->output_offset
4537 - pe_data (abfd
)->pe_opthdr
.ImageBase
);
4541 (_("%pB: unable to fill in DataDictionary[9] because __tls_used is missing"),
4545 /* According to PECOFF sepcifications by Microsoft version 8.2
4546 the TLS data directory consists of 4 pointers, followed
4547 by two 4-byte integer. This implies that the total size
4548 is different for 32-bit and 64-bit executables. */
4549 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
4550 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x18;
4552 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x28;
4556 /* If there is a .pdata section and we have linked pdata finally, we
4557 need to sort the entries ascending. */
4558 #if !defined(COFF_WITH_pep) && (defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64))
4560 asection
*sec
= bfd_get_section_by_name (abfd
, ".pdata");
4564 bfd_size_type x
= sec
->rawsize
;
4567 if (bfd_malloc_and_get_section (abfd
, sec
, &tmp_data
))
4571 12, sort_x64_pdata
);
4572 bfd_set_section_contents (pfinfo
->output_bfd
, sec
,
4582 rsrc_process_section (abfd
, pfinfo
);
4584 /* If we couldn't find idata$2, we either have an excessively
4585 trivial program or are in DEEP trouble; we have to assume trivial