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)
842 time_t now
= bfd_get_current_time (0);
843 H_PUT_32 (abfd
, now
, filehdr_out
->f_timdat
);
846 H_PUT_32 (abfd
, pe_data (abfd
)->timestamp
, filehdr_out
->f_timdat
);
848 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
849 filehdr_out
->f_symptr
);
850 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
851 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
852 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
854 /* Put in extra dos header stuff. This data remains essentially
855 constant, it just has to be tacked on to the beginning of all exes
857 H_PUT_16 (abfd
, filehdr_in
->pe
.e_magic
, filehdr_out
->e_magic
);
858 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cblp
, filehdr_out
->e_cblp
);
859 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cp
, filehdr_out
->e_cp
);
860 H_PUT_16 (abfd
, filehdr_in
->pe
.e_crlc
, filehdr_out
->e_crlc
);
861 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cparhdr
, filehdr_out
->e_cparhdr
);
862 H_PUT_16 (abfd
, filehdr_in
->pe
.e_minalloc
, filehdr_out
->e_minalloc
);
863 H_PUT_16 (abfd
, filehdr_in
->pe
.e_maxalloc
, filehdr_out
->e_maxalloc
);
864 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ss
, filehdr_out
->e_ss
);
865 H_PUT_16 (abfd
, filehdr_in
->pe
.e_sp
, filehdr_out
->e_sp
);
866 H_PUT_16 (abfd
, filehdr_in
->pe
.e_csum
, filehdr_out
->e_csum
);
867 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ip
, filehdr_out
->e_ip
);
868 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cs
, filehdr_out
->e_cs
);
869 H_PUT_16 (abfd
, filehdr_in
->pe
.e_lfarlc
, filehdr_out
->e_lfarlc
);
870 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ovno
, filehdr_out
->e_ovno
);
872 for (idx
= 0; idx
< 4; idx
++)
873 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res
[idx
], filehdr_out
->e_res
[idx
]);
875 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oemid
, filehdr_out
->e_oemid
);
876 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oeminfo
, filehdr_out
->e_oeminfo
);
878 for (idx
= 0; idx
< 10; idx
++)
879 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res2
[idx
], filehdr_out
->e_res2
[idx
]);
881 H_PUT_32 (abfd
, filehdr_in
->pe
.e_lfanew
, filehdr_out
->e_lfanew
);
883 memcpy (filehdr_out
->dos_message
, filehdr_in
->pe
.dos_message
,
884 sizeof (filehdr_out
->dos_message
));
886 /* Also put in the NT signature. */
887 H_PUT_32 (abfd
, filehdr_in
->pe
.nt_signature
, filehdr_out
->nt_signature
);
893 _bfd_XX_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
895 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
896 FILHDR
*filehdr_out
= (FILHDR
*) out
;
898 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
899 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
900 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->f_timdat
);
901 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
, filehdr_out
->f_symptr
);
902 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
903 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
904 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
910 _bfd_XXi_swap_scnhdr_out (bfd
* abfd
, void * in
, void * out
)
912 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*) in
;
913 SCNHDR
*scnhdr_ext
= (SCNHDR
*) out
;
914 unsigned int ret
= SCNHSZ
;
918 memcpy (scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof (scnhdr_int
->s_name
));
920 ss
= scnhdr_int
->s_vaddr
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
921 if (scnhdr_int
->s_vaddr
< pe_data (abfd
)->pe_opthdr
.ImageBase
)
922 _bfd_error_handler (_("%pB:%.8s: section below image base"),
923 abfd
, scnhdr_int
->s_name
);
924 /* Do not compare lower 32-bits for 64-bit vma. */
925 #if !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
926 else if(ss
!= (ss
& 0xffffffff))
927 _bfd_error_handler (_("%pB:%.8s: RVA truncated"), abfd
, scnhdr_int
->s_name
);
928 PUT_SCNHDR_VADDR (abfd
, ss
& 0xffffffff, scnhdr_ext
->s_vaddr
);
930 PUT_SCNHDR_VADDR (abfd
, ss
, scnhdr_ext
->s_vaddr
);
933 /* NT wants the size data to be rounded up to the next
934 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
936 if ((scnhdr_int
->s_flags
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
) != 0)
938 if (bfd_pei_p (abfd
))
940 ps
= scnhdr_int
->s_size
;
946 ss
= scnhdr_int
->s_size
;
951 if (bfd_pei_p (abfd
))
952 ps
= scnhdr_int
->s_paddr
;
956 ss
= scnhdr_int
->s_size
;
959 PUT_SCNHDR_SIZE (abfd
, ss
,
962 /* s_paddr in PE is really the virtual size. */
963 PUT_SCNHDR_PADDR (abfd
, ps
, scnhdr_ext
->s_paddr
);
965 PUT_SCNHDR_SCNPTR (abfd
, scnhdr_int
->s_scnptr
,
966 scnhdr_ext
->s_scnptr
);
967 PUT_SCNHDR_RELPTR (abfd
, scnhdr_int
->s_relptr
,
968 scnhdr_ext
->s_relptr
);
969 PUT_SCNHDR_LNNOPTR (abfd
, scnhdr_int
->s_lnnoptr
,
970 scnhdr_ext
->s_lnnoptr
);
973 /* Extra flags must be set when dealing with PE. All sections should also
974 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
975 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
976 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
977 (this is especially important when dealing with the .idata section since
978 the addresses for routines from .dlls must be overwritten). If .reloc
979 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
980 (0x02000000). Also, the resource data should also be read and
983 /* FIXME: Alignment is also encoded in this field, at least on
984 ARM-WINCE. Although - how do we get the original alignment field
989 char section_name
[SCNNMLEN
];
990 unsigned long must_have
;
992 pe_required_section_flags
;
994 pe_required_section_flags known_sections
[] =
996 { ".arch", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
| IMAGE_SCN_ALIGN_8BYTES
},
997 { ".bss", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
998 { ".data", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
999 { ".edata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1000 { ".idata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1001 { ".pdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1002 { ".rdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1003 { ".reloc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
},
1004 { ".rsrc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1005 { ".text" , IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_CODE
| IMAGE_SCN_MEM_EXECUTE
},
1006 { ".tls", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1007 { ".xdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1010 pe_required_section_flags
* p
;
1012 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1013 we know exactly what this specific section wants so we remove it
1014 and then allow the must_have field to add it back in if necessary.
1015 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1016 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
1017 by ld --enable-auto-import (if auto-import is actually needed),
1018 by ld --omagic, or by obcopy --writable-text. */
1020 for (p
= known_sections
;
1021 p
< known_sections
+ ARRAY_SIZE (known_sections
);
1023 if (memcmp (scnhdr_int
->s_name
, p
->section_name
, SCNNMLEN
) == 0)
1025 if (memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text")
1026 || (bfd_get_file_flags (abfd
) & WP_TEXT
))
1027 scnhdr_int
->s_flags
&= ~IMAGE_SCN_MEM_WRITE
;
1028 scnhdr_int
->s_flags
|= p
->must_have
;
1032 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1035 if (coff_data (abfd
)->link_info
1036 && ! bfd_link_relocatable (coff_data (abfd
)->link_info
)
1037 && ! bfd_link_pic (coff_data (abfd
)->link_info
)
1038 && memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text") == 0)
1040 /* By inference from looking at MS output, the 32 bit field
1041 which is the combination of the number_of_relocs and
1042 number_of_linenos is used for the line number count in
1043 executables. A 16-bit field won't do for cc1. The MS
1044 document says that the number of relocs is zero for
1045 executables, but the 17-th bit has been observed to be there.
1046 Overflow is not an issue: a 4G-line program will overflow a
1047 bunch of other fields long before this! */
1048 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
& 0xffff), scnhdr_ext
->s_nlnno
);
1049 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
>> 16), scnhdr_ext
->s_nreloc
);
1053 if (scnhdr_int
->s_nlnno
<= 0xffff)
1054 H_PUT_16 (abfd
, scnhdr_int
->s_nlnno
, scnhdr_ext
->s_nlnno
);
1057 /* xgettext:c-format */
1058 _bfd_error_handler (_("%pB: line number overflow: 0x%lx > 0xffff"),
1059 abfd
, scnhdr_int
->s_nlnno
);
1060 bfd_set_error (bfd_error_file_truncated
);
1061 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nlnno
);
1065 /* Although we could encode 0xffff relocs here, we do not, to be
1066 consistent with other parts of bfd. Also it lets us warn, as
1067 we should never see 0xffff here w/o having the overflow flag
1069 if (scnhdr_int
->s_nreloc
< 0xffff)
1070 H_PUT_16 (abfd
, scnhdr_int
->s_nreloc
, scnhdr_ext
->s_nreloc
);
1073 /* PE can deal with large #s of relocs, but not here. */
1074 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nreloc
);
1075 scnhdr_int
->s_flags
|= IMAGE_SCN_LNK_NRELOC_OVFL
;
1076 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1083 _bfd_XXi_swap_debugdir_in (bfd
* abfd
, void * ext1
, void * in1
)
1085 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) ext1
;
1086 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) in1
;
1088 in
->Characteristics
= H_GET_32(abfd
, ext
->Characteristics
);
1089 in
->TimeDateStamp
= H_GET_32(abfd
, ext
->TimeDateStamp
);
1090 in
->MajorVersion
= H_GET_16(abfd
, ext
->MajorVersion
);
1091 in
->MinorVersion
= H_GET_16(abfd
, ext
->MinorVersion
);
1092 in
->Type
= H_GET_32(abfd
, ext
->Type
);
1093 in
->SizeOfData
= H_GET_32(abfd
, ext
->SizeOfData
);
1094 in
->AddressOfRawData
= H_GET_32(abfd
, ext
->AddressOfRawData
);
1095 in
->PointerToRawData
= H_GET_32(abfd
, ext
->PointerToRawData
);
1099 _bfd_XXi_swap_debugdir_out (bfd
* abfd
, void * inp
, void * extp
)
1101 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) extp
;
1102 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) inp
;
1104 H_PUT_32(abfd
, in
->Characteristics
, ext
->Characteristics
);
1105 H_PUT_32(abfd
, in
->TimeDateStamp
, ext
->TimeDateStamp
);
1106 H_PUT_16(abfd
, in
->MajorVersion
, ext
->MajorVersion
);
1107 H_PUT_16(abfd
, in
->MinorVersion
, ext
->MinorVersion
);
1108 H_PUT_32(abfd
, in
->Type
, ext
->Type
);
1109 H_PUT_32(abfd
, in
->SizeOfData
, ext
->SizeOfData
);
1110 H_PUT_32(abfd
, in
->AddressOfRawData
, ext
->AddressOfRawData
);
1111 H_PUT_32(abfd
, in
->PointerToRawData
, ext
->PointerToRawData
);
1113 return sizeof (struct external_IMAGE_DEBUG_DIRECTORY
);
1117 _bfd_XXi_slurp_codeview_record (bfd
* abfd
, file_ptr where
, unsigned long length
, CODEVIEW_INFO
*cvinfo
,
1121 bfd_size_type nread
;
1123 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1126 if (length
<= sizeof (CV_INFO_PDB70
) && length
<= sizeof (CV_INFO_PDB20
))
1130 nread
= bfd_read (buffer
, length
, abfd
);
1131 if (length
!= nread
)
1134 /* Ensure null termination of filename. */
1135 memset (buffer
+ nread
, 0, sizeof (buffer
) - nread
);
1137 cvinfo
->CVSignature
= H_GET_32 (abfd
, buffer
);
1140 if ((cvinfo
->CVSignature
== CVINFO_PDB70_CVSIGNATURE
)
1141 && (length
> sizeof (CV_INFO_PDB70
)))
1143 CV_INFO_PDB70
*cvinfo70
= (CV_INFO_PDB70
*)(buffer
);
1145 cvinfo
->Age
= H_GET_32(abfd
, cvinfo70
->Age
);
1147 /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1148 by 8 single bytes. Byte swap them so we can conveniently treat the GUID
1149 as 16 bytes in big-endian order. */
1150 bfd_putb32 (bfd_getl32 (cvinfo70
->Signature
), cvinfo
->Signature
);
1151 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[4])), &(cvinfo
->Signature
[4]));
1152 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[6])), &(cvinfo
->Signature
[6]));
1153 memcpy (&(cvinfo
->Signature
[8]), &(cvinfo70
->Signature
[8]), 8);
1155 cvinfo
->SignatureLength
= CV_INFO_SIGNATURE_LENGTH
;
1156 /* cvinfo->PdbFileName = cvinfo70->PdbFileName; */
1159 *pdb
= xstrdup (cvinfo70
->PdbFileName
);
1163 else if ((cvinfo
->CVSignature
== CVINFO_PDB20_CVSIGNATURE
)
1164 && (length
> sizeof (CV_INFO_PDB20
)))
1166 CV_INFO_PDB20
*cvinfo20
= (CV_INFO_PDB20
*)(buffer
);
1167 cvinfo
->Age
= H_GET_32(abfd
, cvinfo20
->Age
);
1168 memcpy (cvinfo
->Signature
, cvinfo20
->Signature
, 4);
1169 cvinfo
->SignatureLength
= 4;
1170 /* cvinfo->PdbFileName = cvinfo20->PdbFileName; */
1173 *pdb
= xstrdup (cvinfo20
->PdbFileName
);
1182 _bfd_XXi_write_codeview_record (bfd
* abfd
, file_ptr where
, CODEVIEW_INFO
*cvinfo
,
1185 size_t pdb_len
= pdb
? strlen (pdb
) : 0;
1186 const bfd_size_type size
= sizeof (CV_INFO_PDB70
) + pdb_len
+ 1;
1187 bfd_size_type written
;
1188 CV_INFO_PDB70
*cvinfo70
;
1191 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1194 buffer
= bfd_malloc (size
);
1198 cvinfo70
= (CV_INFO_PDB70
*) buffer
;
1199 H_PUT_32 (abfd
, CVINFO_PDB70_CVSIGNATURE
, cvinfo70
->CvSignature
);
1201 /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1202 in little-endian order, followed by 8 single bytes. */
1203 bfd_putl32 (bfd_getb32 (cvinfo
->Signature
), cvinfo70
->Signature
);
1204 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[4])), &(cvinfo70
->Signature
[4]));
1205 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[6])), &(cvinfo70
->Signature
[6]));
1206 memcpy (&(cvinfo70
->Signature
[8]), &(cvinfo
->Signature
[8]), 8);
1208 H_PUT_32 (abfd
, cvinfo
->Age
, cvinfo70
->Age
);
1211 cvinfo70
->PdbFileName
[0] = '\0';
1213 memcpy (cvinfo70
->PdbFileName
, pdb
, pdb_len
+ 1);
1215 written
= bfd_write (buffer
, size
, abfd
);
1219 return written
== size
? size
: 0;
1222 static char * dir_names
[IMAGE_NUMBEROF_DIRECTORY_ENTRIES
] =
1224 N_("Export Directory [.edata (or where ever we found it)]"),
1225 N_("Import Directory [parts of .idata]"),
1226 N_("Resource Directory [.rsrc]"),
1227 N_("Exception Directory [.pdata]"),
1228 N_("Security Directory"),
1229 N_("Base Relocation Directory [.reloc]"),
1230 N_("Debug Directory"),
1231 N_("Description Directory"),
1232 N_("Special Directory"),
1233 N_("Thread Storage Directory [.tls]"),
1234 N_("Load Configuration Directory"),
1235 N_("Bound Import Directory"),
1236 N_("Import Address Table Directory"),
1237 N_("Delay Import Directory"),
1238 N_("CLR Runtime Header"),
1243 get_contents_sanity_check (bfd
*abfd
, asection
*section
,
1244 bfd_size_type dataoff
, bfd_size_type datasize
)
1246 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
1248 if (dataoff
> section
->size
1249 || datasize
> section
->size
- dataoff
)
1251 ufile_ptr filesize
= bfd_get_file_size (abfd
);
1253 && ((ufile_ptr
) section
->filepos
> filesize
1254 || dataoff
> filesize
- section
->filepos
1255 || datasize
> filesize
- section
->filepos
- dataoff
))
1261 pe_print_idata (bfd
* abfd
, void * vfile
)
1263 FILE *file
= (FILE *) vfile
;
1267 bfd_size_type datasize
= 0;
1268 bfd_size_type dataoff
;
1272 pe_data_type
*pe
= pe_data (abfd
);
1273 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1277 addr
= extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
;
1279 if (addr
== 0 && extra
->DataDirectory
[PE_IMPORT_TABLE
].Size
== 0)
1281 /* Maybe the extra header isn't there. Look for the section. */
1282 section
= bfd_get_section_by_name (abfd
, ".idata");
1283 if (section
== NULL
|| (section
->flags
& SEC_HAS_CONTENTS
) == 0)
1286 addr
= section
->vma
;
1287 datasize
= section
->size
;
1293 addr
+= extra
->ImageBase
;
1294 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1296 datasize
= section
->size
;
1297 if (addr
>= section
->vma
&& addr
< section
->vma
+ datasize
)
1301 if (section
== NULL
)
1304 _("\nThere is an import table, but the section containing it could not be found\n"));
1307 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1310 _("\nThere is an import table in %s, but that section has no contents\n"),
1316 /* xgettext:c-format */
1317 fprintf (file
, _("\nThere is an import table in %s at 0x%lx\n"),
1318 section
->name
, (unsigned long) addr
);
1320 dataoff
= addr
- section
->vma
;
1323 _("\nThe Import Tables (interpreted %s section contents)\n"),
1327 vma: Hint Time Forward DLL First\n\
1328 Table Stamp Chain Name Thunk\n"));
1330 /* Read the whole section. Some of the fields might be before dataoff. */
1331 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
1337 adj
= section
->vma
- extra
->ImageBase
;
1339 /* Print all image import descriptors. */
1340 for (i
= dataoff
; i
+ onaline
<= datasize
; i
+= onaline
)
1344 bfd_vma forward_chain
;
1346 bfd_vma first_thunk
;
1351 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1352 fprintf (file
, " %08lx\t", (unsigned long) (i
+ adj
));
1353 hint_addr
= bfd_get_32 (abfd
, data
+ i
);
1354 time_stamp
= bfd_get_32 (abfd
, data
+ i
+ 4);
1355 forward_chain
= bfd_get_32 (abfd
, data
+ i
+ 8);
1356 dll_name
= bfd_get_32 (abfd
, data
+ i
+ 12);
1357 first_thunk
= bfd_get_32 (abfd
, data
+ i
+ 16);
1359 fprintf (file
, "%08lx %08lx %08lx %08lx %08lx\n",
1360 (unsigned long) hint_addr
,
1361 (unsigned long) time_stamp
,
1362 (unsigned long) forward_chain
,
1363 (unsigned long) dll_name
,
1364 (unsigned long) first_thunk
);
1366 if (hint_addr
== 0 && first_thunk
== 0)
1369 if (dll_name
- adj
>= section
->size
)
1372 dll
= (char *) data
+ dll_name
- adj
;
1373 /* PR 17512 file: 078-12277-0.004. */
1374 bfd_size_type maxlen
= (char *)(data
+ datasize
) - dll
- 1;
1375 fprintf (file
, _("\n\tDLL Name: %.*s\n"), (int) maxlen
, dll
);
1377 /* PR 21546: When the Hint Address is zero,
1378 we try the First Thunk instead. */
1380 hint_addr
= first_thunk
;
1382 if (hint_addr
!= 0 && hint_addr
- adj
< datasize
)
1385 asection
*ft_section
;
1387 bfd_size_type ft_datasize
;
1391 fprintf (file
, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1393 idx
= hint_addr
- adj
;
1395 ft_addr
= first_thunk
+ extra
->ImageBase
;
1396 ft_idx
= first_thunk
- adj
;
1397 ft_data
= data
+ ft_idx
;
1398 ft_datasize
= datasize
- ft_idx
;
1401 if (first_thunk
!= hint_addr
)
1403 /* Find the section which contains the first thunk. */
1404 for (ft_section
= abfd
->sections
;
1406 ft_section
= ft_section
->next
)
1408 if (ft_addr
>= ft_section
->vma
1409 && ft_addr
< ft_section
->vma
+ ft_section
->size
)
1413 if (ft_section
== NULL
)
1416 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1420 /* Now check to see if this section is the same as our current
1421 section. If it is not then we will have to load its data in. */
1422 if (ft_section
!= section
)
1424 ft_idx
= first_thunk
- (ft_section
->vma
- extra
->ImageBase
);
1425 ft_datasize
= ft_section
->size
- ft_idx
;
1426 if (!get_contents_sanity_check (abfd
, ft_section
,
1427 ft_idx
, ft_datasize
))
1429 ft_data
= (bfd_byte
*) bfd_malloc (ft_datasize
);
1430 if (ft_data
== NULL
)
1433 /* Read ft_datasize bytes starting at offset ft_idx. */
1434 if (!bfd_get_section_contents (abfd
, ft_section
, ft_data
,
1435 (bfd_vma
) ft_idx
, ft_datasize
))
1444 /* Print HintName vector entries. */
1445 #ifdef COFF_WITH_pex64
1446 for (j
= 0; idx
+ j
+ 8 <= datasize
; j
+= 8)
1449 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1450 unsigned long member_high
= bfd_get_32 (abfd
, data
+ idx
+ j
+ 4);
1452 if (!member
&& !member_high
)
1457 if (HighBitSet (member_high
))
1458 fprintf (file
, "\t%lx%08lx\t %4lx%08lx <none>",
1459 member_high
, member
,
1460 WithoutHighBit (member_high
), member
);
1461 /* PR binutils/17512: Handle corrupt PE data. */
1462 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1463 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1469 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1470 member_name
= (char *) data
+ amt
+ 2;
1471 fprintf (file
, "\t%04lx\t %4d %.*s",member
, ordinal
,
1472 (int) (datasize
- (amt
+ 2)), member_name
);
1475 /* If the time stamp is not zero, the import address
1476 table holds actual addresses. */
1479 && first_thunk
!= hint_addr
1480 && j
+ 4 <= ft_datasize
)
1481 fprintf (file
, "\t%04lx",
1482 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1483 fprintf (file
, "\n");
1486 for (j
= 0; idx
+ j
+ 4 <= datasize
; j
+= 4)
1489 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1491 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1497 if (HighBitSet (member
))
1498 fprintf (file
, "\t%04lx\t %4lu <none>",
1499 member
, WithoutHighBit (member
));
1500 /* PR binutils/17512: Handle corrupt PE data. */
1501 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1502 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1508 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1509 member_name
= (char *) data
+ amt
+ 2;
1510 fprintf (file
, "\t%04lx\t %4d %.*s",
1512 (int) (datasize
- (amt
+ 2)), member_name
);
1515 /* If the time stamp is not zero, the import address
1516 table holds actual addresses. */
1519 && first_thunk
!= hint_addr
1520 && j
+ 4 <= ft_datasize
)
1521 fprintf (file
, "\t%04lx",
1522 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1524 fprintf (file
, "\n");
1531 fprintf (file
, "\n");
1540 pe_print_edata (bfd
* abfd
, void * vfile
)
1542 FILE *file
= (FILE *) vfile
;
1545 bfd_size_type datasize
= 0;
1546 bfd_size_type dataoff
;
1551 long export_flags
; /* Reserved - should be zero. */
1555 bfd_vma name
; /* RVA - relative to image base. */
1556 long base
; /* Ordinal base. */
1557 unsigned long num_functions
;/* Number in the export address table. */
1558 unsigned long num_names
; /* Number in the name pointer table. */
1559 bfd_vma eat_addr
; /* RVA to the export address table. */
1560 bfd_vma npt_addr
; /* RVA to the Export Name Pointer Table. */
1561 bfd_vma ot_addr
; /* RVA to the Ordinal Table. */
1564 pe_data_type
*pe
= pe_data (abfd
);
1565 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1569 addr
= extra
->DataDirectory
[PE_EXPORT_TABLE
].VirtualAddress
;
1571 if (addr
== 0 && extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
== 0)
1573 /* Maybe the extra header isn't there. Look for the section. */
1574 section
= bfd_get_section_by_name (abfd
, ".edata");
1575 if (section
== NULL
)
1578 addr
= section
->vma
;
1580 datasize
= section
->size
;
1586 addr
+= extra
->ImageBase
;
1588 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1589 if (addr
>= section
->vma
&& addr
< section
->vma
+ section
->size
)
1592 if (section
== NULL
)
1595 _("\nThere is an export table, but the section containing it could not be found\n"));
1599 dataoff
= addr
- section
->vma
;
1600 datasize
= extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
;
1603 /* PR 17512: Handle corrupt PE binaries. */
1607 /* xgettext:c-format */
1608 _("\nThere is an export table in %s, but it is too small (%d)\n"),
1609 section
->name
, (int) datasize
);
1613 if (!get_contents_sanity_check (abfd
, section
, dataoff
, datasize
))
1616 _("\nThere is an export table in %s, but contents cannot be read\n"),
1621 /* xgettext:c-format */
1622 fprintf (file
, _("\nThere is an export table in %s at 0x%lx\n"),
1623 section
->name
, (unsigned long) addr
);
1625 data
= (bfd_byte
*) bfd_malloc (datasize
);
1629 if (! bfd_get_section_contents (abfd
, section
, data
,
1630 (file_ptr
) dataoff
, datasize
))
1636 /* Go get Export Directory Table. */
1637 edt
.export_flags
= bfd_get_32 (abfd
, data
+ 0);
1638 edt
.time_stamp
= bfd_get_32 (abfd
, data
+ 4);
1639 edt
.major_ver
= bfd_get_16 (abfd
, data
+ 8);
1640 edt
.minor_ver
= bfd_get_16 (abfd
, data
+ 10);
1641 edt
.name
= bfd_get_32 (abfd
, data
+ 12);
1642 edt
.base
= bfd_get_32 (abfd
, data
+ 16);
1643 edt
.num_functions
= bfd_get_32 (abfd
, data
+ 20);
1644 edt
.num_names
= bfd_get_32 (abfd
, data
+ 24);
1645 edt
.eat_addr
= bfd_get_32 (abfd
, data
+ 28);
1646 edt
.npt_addr
= bfd_get_32 (abfd
, data
+ 32);
1647 edt
.ot_addr
= bfd_get_32 (abfd
, data
+ 36);
1649 adj
= section
->vma
- extra
->ImageBase
+ dataoff
;
1651 /* Dump the EDT first. */
1653 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1657 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt
.export_flags
);
1660 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt
.time_stamp
);
1663 /* xgettext:c-format */
1664 _("Major/Minor \t\t\t%d/%d\n"), edt
.major_ver
, edt
.minor_ver
);
1667 _("Name \t\t\t\t"));
1668 bfd_fprintf_vma (abfd
, file
, edt
.name
);
1670 if ((edt
.name
>= adj
) && (edt
.name
< adj
+ datasize
))
1671 fprintf (file
, " %.*s\n",
1672 (int) (datasize
- (edt
.name
- adj
)),
1673 data
+ edt
.name
- adj
);
1675 fprintf (file
, "(outside .edata section)\n");
1678 _("Ordinal Base \t\t\t%ld\n"), edt
.base
);
1684 _("\tExport Address Table \t\t%08lx\n"),
1688 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt
.num_names
);
1691 _("Table Addresses\n"));
1694 _("\tExport Address Table \t\t"));
1695 bfd_fprintf_vma (abfd
, file
, edt
.eat_addr
);
1696 fprintf (file
, "\n");
1699 _("\tName Pointer Table \t\t"));
1700 bfd_fprintf_vma (abfd
, file
, edt
.npt_addr
);
1701 fprintf (file
, "\n");
1704 _("\tOrdinal Table \t\t\t"));
1705 bfd_fprintf_vma (abfd
, file
, edt
.ot_addr
);
1706 fprintf (file
, "\n");
1708 /* The next table to find is the Export Address Table. It's basically
1709 a list of pointers that either locate a function in this dll, or
1710 forward the call to another dll. Something like:
1715 } export_address_table_entry; */
1718 _("\nExport Address Table -- Ordinal Base %ld\n"),
1721 /* PR 17512: Handle corrupt PE binaries. */
1722 /* PR 17512 file: 140-165018-0.004. */
1723 if (edt
.eat_addr
- adj
>= datasize
1724 /* PR 17512: file: 092b1829 */
1725 || (edt
.num_functions
+ 1) * 4 < edt
.num_functions
1726 || edt
.eat_addr
- adj
+ (edt
.num_functions
+ 1) * 4 > datasize
)
1727 fprintf (file
, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1728 (long) edt
.eat_addr
,
1729 (long) edt
.num_functions
);
1730 else for (i
= 0; i
< edt
.num_functions
; ++i
)
1732 bfd_vma eat_member
= bfd_get_32 (abfd
,
1733 data
+ edt
.eat_addr
+ (i
* 4) - adj
);
1734 if (eat_member
== 0)
1737 if (eat_member
- adj
<= datasize
)
1739 /* This rva is to a name (forwarding function) in our section. */
1740 /* Should locate a function descriptor. */
1742 "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1744 (long) (i
+ edt
.base
),
1745 (unsigned long) eat_member
,
1747 (int)(datasize
- (eat_member
- adj
)),
1748 data
+ eat_member
- adj
);
1752 /* Should locate a function descriptor in the reldata section. */
1754 "\t[%4ld] +base[%4ld] %04lx %s\n",
1756 (long) (i
+ edt
.base
),
1757 (unsigned long) eat_member
,
1762 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1763 /* Dump them in parallel for clarity. */
1765 _("\n[Ordinal/Name Pointer] Table\n"));
1767 /* PR 17512: Handle corrupt PE binaries. */
1768 if (edt
.npt_addr
+ (edt
.num_names
* 4) - adj
>= datasize
1769 /* PR 17512: file: bb68816e. */
1770 || edt
.num_names
* 4 < edt
.num_names
1771 || (data
+ edt
.npt_addr
- adj
) < data
)
1772 /* xgettext:c-format */
1773 fprintf (file
, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1774 (long) edt
.npt_addr
,
1775 (long) edt
.num_names
);
1776 /* PR 17512: file: 140-147171-0.004. */
1777 else if (edt
.ot_addr
+ (edt
.num_names
* 2) - adj
>= datasize
1778 || data
+ edt
.ot_addr
- adj
< data
)
1779 /* xgettext:c-format */
1780 fprintf (file
, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1782 (long) edt
.num_names
);
1783 else for (i
= 0; i
< edt
.num_names
; ++i
)
1788 ord
= bfd_get_16 (abfd
, data
+ edt
.ot_addr
+ (i
* 2) - adj
);
1789 name_ptr
= bfd_get_32 (abfd
, data
+ edt
.npt_addr
+ (i
* 4) - adj
);
1791 if ((name_ptr
- adj
) >= datasize
)
1793 /* xgettext:c-format */
1794 fprintf (file
, _("\t[%4ld] <corrupt offset: %lx>\n"),
1795 (long) ord
, (long) name_ptr
);
1799 char * name
= (char *) data
+ name_ptr
- adj
;
1801 fprintf (file
, "\t[%4ld] %.*s\n", (long) ord
,
1802 (int)((char *)(data
+ datasize
) - name
), name
);
1811 /* This really is architecture dependent. On IA-64, a .pdata entry
1812 consists of three dwords containing relative virtual addresses that
1813 specify the start and end address of the code range the entry
1814 covers and the address of the corresponding unwind info data.
1816 On ARM and SH-4, a compressed PDATA structure is used :
1817 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1818 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1819 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1821 This is the version for uncompressed data. */
1824 pe_print_pdata (bfd
* abfd
, void * vfile
)
1826 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
1827 # define PDATA_ROW_SIZE (3 * 8)
1829 # define PDATA_ROW_SIZE (5 * 4)
1831 FILE *file
= (FILE *) vfile
;
1833 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1834 bfd_size_type datasize
= 0;
1836 bfd_size_type start
, stop
;
1837 int onaline
= PDATA_ROW_SIZE
;
1840 || (section
->flags
& SEC_HAS_CONTENTS
) == 0
1841 || coff_section_data (abfd
, section
) == NULL
1842 || pei_section_data (abfd
, section
) == NULL
)
1845 stop
= pei_section_data (abfd
, section
)->virt_size
;
1846 if ((stop
% onaline
) != 0)
1848 /* xgettext:c-format */
1849 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
1850 (long) stop
, onaline
);
1853 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1854 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
1856 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1859 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1860 \t\tAddress Address Handler Data Address Mask\n"));
1863 datasize
= section
->size
;
1867 /* PR 17512: file: 002-193900-0.004. */
1868 if (datasize
< stop
)
1870 /* xgettext:c-format */
1871 fprintf (file
, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"),
1872 (long) stop
, (long) datasize
);
1876 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
1884 for (i
= start
; i
< stop
; i
+= onaline
)
1890 bfd_vma prolog_end_addr
;
1891 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64)
1895 if (i
+ PDATA_ROW_SIZE
> stop
)
1898 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
1899 end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
1900 eh_handler
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 8);
1901 eh_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 12);
1902 prolog_end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 16);
1904 if (begin_addr
== 0 && end_addr
== 0 && eh_handler
== 0
1905 && eh_data
== 0 && prolog_end_addr
== 0)
1906 /* We are probably into the padding of the section now. */
1909 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64)
1910 em_data
= ((eh_handler
& 0x1) << 2) | (prolog_end_addr
& 0x3);
1912 eh_handler
&= ~(bfd_vma
) 0x3;
1913 prolog_end_addr
&= ~(bfd_vma
) 0x3;
1916 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
1917 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
1918 bfd_fprintf_vma (abfd
, file
, end_addr
); fputc (' ', file
);
1919 bfd_fprintf_vma (abfd
, file
, eh_handler
);
1920 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64)
1922 bfd_fprintf_vma (abfd
, file
, eh_data
); fputc (' ', file
);
1923 bfd_fprintf_vma (abfd
, file
, prolog_end_addr
);
1924 fprintf (file
, " %x", em_data
);
1926 fprintf (file
, "\n");
1932 #undef PDATA_ROW_SIZE
1935 typedef struct sym_cache
1942 slurp_symtab (bfd
*abfd
, sym_cache
*psc
)
1944 asymbol
** sy
= NULL
;
1947 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1953 storage
= bfd_get_symtab_upper_bound (abfd
);
1958 sy
= (asymbol
**) bfd_malloc (storage
);
1963 psc
->symcount
= bfd_canonicalize_symtab (abfd
, sy
);
1964 if (psc
->symcount
< 0)
1970 my_symbol_for_address (bfd
*abfd
, bfd_vma func
, sym_cache
*psc
)
1975 psc
->syms
= slurp_symtab (abfd
, psc
);
1977 for (i
= 0; i
< psc
->symcount
; i
++)
1979 if (psc
->syms
[i
]->section
->vma
+ psc
->syms
[i
]->value
== func
)
1980 return psc
->syms
[i
]->name
;
1987 cleanup_syms (sym_cache
*psc
)
1994 /* This is the version for "compressed" pdata. */
1997 _bfd_XX_print_ce_compressed_pdata (bfd
* abfd
, void * vfile
)
1999 # define PDATA_ROW_SIZE (2 * 4)
2000 FILE *file
= (FILE *) vfile
;
2001 bfd_byte
*data
= NULL
;
2002 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
2003 bfd_size_type datasize
= 0;
2005 bfd_size_type start
, stop
;
2006 int onaline
= PDATA_ROW_SIZE
;
2007 struct sym_cache cache
= {0, 0} ;
2010 || (section
->flags
& SEC_HAS_CONTENTS
) == 0
2011 || coff_section_data (abfd
, section
) == NULL
2012 || pei_section_data (abfd
, section
) == NULL
)
2015 stop
= pei_section_data (abfd
, section
)->virt_size
;
2016 if ((stop
% onaline
) != 0)
2018 /* xgettext:c-format */
2019 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
2020 (long) stop
, onaline
);
2023 _("\nThe Function Table (interpreted .pdata section contents)\n"));
2026 vma:\t\tBegin Prolog Function Flags Exception EH\n\
2027 \t\tAddress Length Length 32b exc Handler Data\n"));
2029 datasize
= section
->size
;
2033 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2040 if (stop
> datasize
)
2043 for (i
= start
; i
< stop
; i
+= onaline
)
2047 bfd_vma prolog_length
, function_length
;
2048 int flag32bit
, exception_flag
;
2051 if (i
+ PDATA_ROW_SIZE
> stop
)
2054 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
2055 other_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
2057 if (begin_addr
== 0 && other_data
== 0)
2058 /* We are probably into the padding of the section now. */
2061 prolog_length
= (other_data
& 0x000000FF);
2062 function_length
= (other_data
& 0x3FFFFF00) >> 8;
2063 flag32bit
= (int)((other_data
& 0x40000000) >> 30);
2064 exception_flag
= (int)((other_data
& 0x80000000) >> 31);
2067 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
2068 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
2069 bfd_fprintf_vma (abfd
, file
, prolog_length
); fputc (' ', file
);
2070 bfd_fprintf_vma (abfd
, file
, function_length
); fputc (' ', file
);
2071 fprintf (file
, "%2d %2d ", flag32bit
, exception_flag
);
2073 /* Get the exception handler's address and the data passed from the
2074 .text section. This is really the data that belongs with the .pdata
2075 but got "compressed" out for the ARM and SH4 architectures. */
2076 tsection
= bfd_get_section_by_name (abfd
, ".text");
2077 if (tsection
&& coff_section_data (abfd
, tsection
)
2078 && pei_section_data (abfd
, tsection
))
2080 bfd_vma eh_off
= (begin_addr
- 8) - tsection
->vma
;
2083 tdata
= (bfd_byte
*) bfd_malloc (8);
2086 if (bfd_get_section_contents (abfd
, tsection
, tdata
, eh_off
, 8))
2088 bfd_vma eh
, eh_data
;
2090 eh
= bfd_get_32 (abfd
, tdata
);
2091 eh_data
= bfd_get_32 (abfd
, tdata
+ 4);
2092 fprintf (file
, "%08x ", (unsigned int) eh
);
2093 fprintf (file
, "%08x", (unsigned int) eh_data
);
2096 const char *s
= my_symbol_for_address (abfd
, eh
, &cache
);
2099 fprintf (file
, " (%s) ", s
);
2106 fprintf (file
, "\n");
2111 cleanup_syms (& cache
);
2114 #undef PDATA_ROW_SIZE
2118 #define IMAGE_REL_BASED_HIGHADJ 4
2119 static const char * const tbl
[] =
2133 "UNKNOWN", /* MUST be last. */
2137 pe_print_reloc (bfd
* abfd
, void * vfile
)
2139 FILE *file
= (FILE *) vfile
;
2141 asection
*section
= bfd_get_section_by_name (abfd
, ".reloc");
2145 || section
->size
== 0
2146 || (section
->flags
& SEC_HAS_CONTENTS
) == 0)
2150 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2152 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2159 end
= data
+ section
->size
;
2160 while (p
+ 8 <= end
)
2163 bfd_vma virtual_address
;
2164 unsigned long number
, size
;
2165 bfd_byte
*chunk_end
;
2167 /* The .reloc section is a sequence of blocks, with a header consisting
2168 of two 32 bit quantities, followed by a number of 16 bit entries. */
2169 virtual_address
= bfd_get_32 (abfd
, p
);
2170 size
= bfd_get_32 (abfd
, p
+ 4);
2172 number
= (size
- 8) / 2;
2178 /* xgettext:c-format */
2179 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2180 (unsigned long) virtual_address
, size
, size
, number
);
2182 chunk_end
= p
- 8 + size
;
2183 if (chunk_end
> end
)
2186 while (p
+ 2 <= chunk_end
)
2188 unsigned short e
= bfd_get_16 (abfd
, p
);
2189 unsigned int t
= (e
& 0xF000) >> 12;
2190 int off
= e
& 0x0FFF;
2192 if (t
>= sizeof (tbl
) / sizeof (tbl
[0]))
2193 t
= (sizeof (tbl
) / sizeof (tbl
[0])) - 1;
2196 /* xgettext:c-format */
2197 _("\treloc %4d offset %4x [%4lx] %s"),
2198 j
, off
, (unsigned long) (off
+ virtual_address
), tbl
[t
]);
2203 /* HIGHADJ takes an argument, - the next record *is* the
2204 low 16 bits of addend. */
2205 if (t
== IMAGE_REL_BASED_HIGHADJ
&& p
+ 2 <= chunk_end
)
2207 fprintf (file
, " (%4x)", (unsigned int) bfd_get_16 (abfd
, p
));
2212 fprintf (file
, "\n");
2221 /* A data structure describing the regions of a .rsrc section.
2222 Some fields are filled in as the section is parsed. */
2224 typedef struct rsrc_regions
2226 bfd_byte
* section_start
;
2227 bfd_byte
* section_end
;
2228 bfd_byte
* strings_start
;
2229 bfd_byte
* resource_start
;
2233 rsrc_print_resource_directory (FILE * , bfd
*, unsigned int, bfd_byte
*,
2234 rsrc_regions
*, bfd_vma
);
2236 /* Print the resource entry at DATA, with the text indented by INDENT.
2237 Recusively calls rsrc_print_resource_directory to print the contents
2238 of directory entries.
2239 Returns the address of the end of the data associated with the entry
2240 or section_end + 1 upon failure. */
2243 rsrc_print_resource_entries (FILE *file
,
2245 unsigned int indent
,
2248 rsrc_regions
*regions
,
2251 unsigned long entry
, addr
, size
;
2254 if (data
+ 8 >= regions
->section_end
)
2255 return regions
->section_end
+ 1;
2257 /* xgettext:c-format */
2258 fprintf (file
, _("%03x %*.s Entry: "), (int)(data
- regions
->section_start
), indent
, " ");
2260 entry
= (unsigned long) bfd_get_32 (abfd
, data
);
2265 /* Note - the documentation says that this field is an RVA value
2266 but windres appears to produce a section relative offset with
2267 the top bit set. Support both styles for now. */
2268 if (HighBitSet (entry
))
2269 name
= regions
->section_start
+ WithoutHighBit (entry
);
2271 name
= regions
->section_start
+ entry
- rva_bias
;
2273 if (name
+ 2 < regions
->section_end
&& name
> regions
->section_start
)
2277 if (regions
->strings_start
== NULL
)
2278 regions
->strings_start
= name
;
2280 len
= bfd_get_16 (abfd
, name
);
2282 fprintf (file
, _("name: [val: %08lx len %d]: "), entry
, len
);
2284 if (name
+ 2 + len
* 2 < regions
->section_end
)
2286 /* This strange loop is to cope with multibyte characters. */
2293 /* Avoid printing control characters. */
2294 if (c
> 0 && c
< 32)
2295 fprintf (file
, "^%c", c
+ 64);
2297 fprintf (file
, "%.1s", name
);
2302 fprintf (file
, _("<corrupt string length: %#x>\n"), len
);
2303 /* PR binutils/17512: Do not try to continue decoding a
2304 corrupted resource section. It is likely to end up with
2305 reams of extraneous output. FIXME: We could probably
2306 continue if we disable the printing of strings... */
2307 return regions
->section_end
+ 1;
2312 fprintf (file
, _("<corrupt string offset: %#lx>\n"), entry
);
2313 return regions
->section_end
+ 1;
2317 fprintf (file
, _("ID: %#08lx"), entry
);
2319 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
2320 fprintf (file
, _(", Value: %#08lx\n"), entry
);
2322 if (HighBitSet (entry
))
2324 data
= regions
->section_start
+ WithoutHighBit (entry
);
2325 if (data
<= regions
->section_start
|| data
> regions
->section_end
)
2326 return regions
->section_end
+ 1;
2328 /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2329 in the resource table. We need some way to detect this. */
2330 return rsrc_print_resource_directory (file
, abfd
, indent
+ 1, data
,
2334 leaf
= regions
->section_start
+ entry
;
2336 if (leaf
+ 16 >= regions
->section_end
2337 /* PR 17512: file: 055dff7e. */
2338 || leaf
< regions
->section_start
)
2339 return regions
->section_end
+ 1;
2341 /* xgettext:c-format */
2342 fprintf (file
, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2343 (int) (entry
), indent
, " ",
2344 addr
= (long) bfd_get_32 (abfd
, leaf
),
2345 size
= (long) bfd_get_32 (abfd
, leaf
+ 4),
2346 (int) bfd_get_32 (abfd
, leaf
+ 8));
2348 /* Check that the reserved entry is 0. */
2349 if (bfd_get_32 (abfd
, leaf
+ 12) != 0
2350 /* And that the data address/size is valid too. */
2351 || (regions
->section_start
+ (addr
- rva_bias
) + size
> regions
->section_end
))
2352 return regions
->section_end
+ 1;
2354 if (regions
->resource_start
== NULL
)
2355 regions
->resource_start
= regions
->section_start
+ (addr
- rva_bias
);
2357 return regions
->section_start
+ (addr
- rva_bias
) + size
;
2360 #define max(a,b) ((a) > (b) ? (a) : (b))
2361 #define min(a,b) ((a) < (b) ? (a) : (b))
2364 rsrc_print_resource_directory (FILE * file
,
2366 unsigned int indent
,
2368 rsrc_regions
* regions
,
2371 unsigned int num_names
, num_ids
;
2372 bfd_byte
* highest_data
= data
;
2374 if (data
+ 16 >= regions
->section_end
)
2375 return regions
->section_end
+ 1;
2377 fprintf (file
, "%03x %*.s ", (int)(data
- regions
->section_start
), indent
, " ");
2380 case 0: fprintf (file
, "Type"); break;
2381 case 2: fprintf (file
, "Name"); break;
2382 case 4: fprintf (file
, "Language"); break;
2384 fprintf (file
, _("<unknown directory type: %d>\n"), indent
);
2385 /* FIXME: For now we end the printing here. If in the
2386 future more directory types are added to the RSRC spec
2387 then we will need to change this. */
2388 return regions
->section_end
+ 1;
2391 /* xgettext:c-format */
2392 fprintf (file
, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2393 (int) bfd_get_32 (abfd
, data
),
2394 (long) bfd_get_32 (abfd
, data
+ 4),
2395 (int) bfd_get_16 (abfd
, data
+ 8),
2396 (int) bfd_get_16 (abfd
, data
+ 10),
2397 num_names
= (int) bfd_get_16 (abfd
, data
+ 12),
2398 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14));
2401 while (num_names
--)
2403 bfd_byte
* entry_end
;
2405 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, true,
2406 data
, regions
, rva_bias
);
2408 highest_data
= max (highest_data
, entry_end
);
2409 if (entry_end
>= regions
->section_end
)
2415 bfd_byte
* entry_end
;
2417 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, false,
2418 data
, regions
, rva_bias
);
2420 highest_data
= max (highest_data
, entry_end
);
2421 if (entry_end
>= regions
->section_end
)
2425 return max (highest_data
, data
);
2428 /* Display the contents of a .rsrc section. We do not try to
2429 reproduce the resources, windres does that. Instead we dump
2430 the tables in a human readable format. */
2433 rsrc_print_section (bfd
* abfd
, void * vfile
)
2437 FILE * file
= (FILE *) vfile
;
2438 bfd_size_type datasize
;
2441 rsrc_regions regions
;
2443 pe
= pe_data (abfd
);
2447 section
= bfd_get_section_by_name (abfd
, ".rsrc");
2448 if (section
== NULL
)
2450 if (!(section
->flags
& SEC_HAS_CONTENTS
))
2453 datasize
= section
->size
;
2457 rva_bias
= section
->vma
- pe
->pe_opthdr
.ImageBase
;
2459 if (! bfd_malloc_and_get_section (abfd
, section
, & data
))
2465 regions
.section_start
= data
;
2466 regions
.section_end
= data
+ datasize
;
2467 regions
.strings_start
= NULL
;
2468 regions
.resource_start
= NULL
;
2471 fprintf (file
, "\nThe .rsrc Resource Directory section:\n");
2473 while (data
< regions
.section_end
)
2475 bfd_byte
* p
= data
;
2477 data
= rsrc_print_resource_directory (file
, abfd
, 0, data
, & regions
, rva_bias
);
2479 if (data
== regions
.section_end
+ 1)
2480 fprintf (file
, _("Corrupt .rsrc section detected!\n"));
2483 /* Align data before continuing. */
2484 int align
= (1 << section
->alignment_power
) - 1;
2486 data
= (bfd_byte
*) (((ptrdiff_t) (data
+ align
)) & ~ align
);
2487 rva_bias
+= data
- p
;
2489 /* For reasons that are unclear .rsrc sections are sometimes created
2490 aligned to a 1^3 boundary even when their alignment is set at
2491 1^2. Catch that case here before we issue a spurious warning
2493 if (data
== (regions
.section_end
- 4))
2494 data
= regions
.section_end
;
2495 else if (data
< regions
.section_end
)
2497 /* If the extra data is all zeros then do not complain.
2498 This is just padding so that the section meets the
2499 page size requirements. */
2500 while (++ data
< regions
.section_end
)
2503 if (data
< regions
.section_end
)
2504 fprintf (file
, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2509 if (regions
.strings_start
!= NULL
)
2510 fprintf (file
, _(" String table starts at offset: %#03x\n"),
2511 (int) (regions
.strings_start
- regions
.section_start
));
2512 if (regions
.resource_start
!= NULL
)
2513 fprintf (file
, _(" Resources start at offset: %#03x\n"),
2514 (int) (regions
.resource_start
- regions
.section_start
));
2516 free (regions
.section_start
);
2520 #define IMAGE_NUMBEROF_DEBUG_TYPES 17
2522 static char * debug_type_names
[IMAGE_NUMBEROF_DEBUG_TYPES
] =
2544 pe_print_debugdata (bfd
* abfd
, void * vfile
)
2546 FILE *file
= (FILE *) vfile
;
2547 pe_data_type
*pe
= pe_data (abfd
);
2548 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2551 bfd_size_type dataoff
;
2554 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2555 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2560 addr
+= extra
->ImageBase
;
2561 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2563 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2567 if (section
== NULL
)
2570 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2573 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
2576 _("\nThere is a debug directory in %s, but that section has no contents\n"),
2580 else if (section
->size
< size
)
2583 _("\nError: section %s contains the debug data starting address but it is too small\n"),
2588 fprintf (file
, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2589 section
->name
, (unsigned long) addr
);
2591 dataoff
= addr
- section
->vma
;
2593 if (size
> (section
->size
- dataoff
))
2595 fprintf (file
, _("The debug data size field in the data directory is too big for the section"));
2600 _("Type Size Rva Offset\n"));
2602 /* Read the whole section. */
2603 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2609 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2611 const char *type_name
;
2612 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2613 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2614 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2616 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2618 if ((idd
.Type
) >= IMAGE_NUMBEROF_DEBUG_TYPES
)
2619 type_name
= debug_type_names
[0];
2621 type_name
= debug_type_names
[idd
.Type
];
2623 fprintf (file
, " %2ld %14s %08lx %08lx %08lx\n",
2624 idd
.Type
, type_name
, idd
.SizeOfData
,
2625 idd
.AddressOfRawData
, idd
.PointerToRawData
);
2627 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_CODEVIEW
)
2629 char signature
[CV_INFO_SIGNATURE_LENGTH
* 2 + 1];
2630 /* PR 17512: file: 065-29434-0.001:0.1
2631 We need to use a 32-bit aligned buffer
2632 to safely read in a codeview record. */
2633 char buffer
[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO
);
2636 CODEVIEW_INFO
*cvinfo
= (CODEVIEW_INFO
*) buffer
;
2638 /* The debug entry doesn't have to have to be in a section,
2639 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2640 if (!_bfd_XXi_slurp_codeview_record (abfd
, (file_ptr
) idd
.PointerToRawData
,
2641 idd
.SizeOfData
, cvinfo
, &pdb
))
2644 for (j
= 0; j
< cvinfo
->SignatureLength
; j
++)
2645 sprintf (&signature
[j
*2], "%02x", cvinfo
->Signature
[j
] & 0xff);
2647 /* xgettext:c-format */
2648 fprintf (file
, _("(format %c%c%c%c signature %s age %ld pdb %s)\n"),
2649 buffer
[0], buffer
[1], buffer
[2], buffer
[3],
2650 signature
, cvinfo
->Age
, pdb
[0] ? pdb
: "(none)");
2658 if (size
% sizeof (struct external_IMAGE_DEBUG_DIRECTORY
) != 0)
2660 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2666 pe_is_repro (bfd
* abfd
)
2668 pe_data_type
*pe
= pe_data (abfd
);
2669 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2672 bfd_size_type dataoff
;
2676 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2677 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2682 addr
+= extra
->ImageBase
;
2683 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2685 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2689 if ((section
== NULL
)
2690 || (!(section
->flags
& SEC_HAS_CONTENTS
))
2691 || (section
->size
< size
))
2696 dataoff
= addr
- section
->vma
;
2698 if (size
> (section
->size
- dataoff
))
2703 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2709 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2711 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2712 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2713 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2715 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2717 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_REPRO
)
2729 /* Print out the program headers. */
2732 _bfd_XX_print_private_bfd_data_common (bfd
* abfd
, void * vfile
)
2734 FILE *file
= (FILE *) vfile
;
2736 pe_data_type
*pe
= pe_data (abfd
);
2737 struct internal_extra_pe_aouthdr
*i
= &pe
->pe_opthdr
;
2738 const char *subsystem_name
= NULL
;
2741 /* The MS dumpbin program reportedly ands with 0xff0f before
2742 printing the characteristics field. Not sure why. No reason to
2744 fprintf (file
, _("\nCharacteristics 0x%x\n"), pe
->real_flags
);
2746 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2747 PF (IMAGE_FILE_RELOCS_STRIPPED
, "relocations stripped");
2748 PF (IMAGE_FILE_EXECUTABLE_IMAGE
, "executable");
2749 PF (IMAGE_FILE_LINE_NUMS_STRIPPED
, "line numbers stripped");
2750 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED
, "symbols stripped");
2751 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE
, "large address aware");
2752 PF (IMAGE_FILE_BYTES_REVERSED_LO
, "little endian");
2753 PF (IMAGE_FILE_32BIT_MACHINE
, "32 bit words");
2754 PF (IMAGE_FILE_DEBUG_STRIPPED
, "debugging information removed");
2755 PF (IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP
, "copy to swap file if on removable media");
2756 PF (IMAGE_FILE_NET_RUN_FROM_SWAP
, "copy to swap file if on network media");
2757 PF (IMAGE_FILE_SYSTEM
, "system file");
2758 PF (IMAGE_FILE_DLL
, "DLL");
2759 PF (IMAGE_FILE_UP_SYSTEM_ONLY
, "run only on uniprocessor machine");
2760 PF (IMAGE_FILE_BYTES_REVERSED_HI
, "big endian");
2764 If a PE_IMAGE_DEBUG_TYPE_REPRO entry is present in the debug directory, the
2765 timestamp is to be interpreted as the hash of a reproducible build.
2767 if (pe_is_repro (abfd
))
2769 fprintf (file
, "\nTime/Date\t\t%08lx", pe
->coff
.timestamp
);
2770 fprintf (file
, "\t(This is a reproducible build file hash, not a timestamp)\n");
2774 /* ctime implies '\n'. */
2775 time_t t
= pe
->coff
.timestamp
;
2776 fprintf (file
, "\nTime/Date\t\t%s", ctime (&t
));
2779 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2780 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2782 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2783 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2785 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2786 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2791 case IMAGE_NT_OPTIONAL_HDR_MAGIC
:
2794 case IMAGE_NT_OPTIONAL_HDR64_MAGIC
:
2797 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC
:
2804 fprintf (file
, "Magic\t\t\t%04x", i
->Magic
);
2806 fprintf (file
, "\t(%s)",name
);
2807 fprintf (file
, "\nMajorLinkerVersion\t%d\n", i
->MajorLinkerVersion
);
2808 fprintf (file
, "MinorLinkerVersion\t%d\n", i
->MinorLinkerVersion
);
2809 fprintf (file
, "SizeOfCode\t\t");
2810 bfd_fprintf_vma (abfd
, file
, i
->SizeOfCode
);
2811 fprintf (file
, "\nSizeOfInitializedData\t");
2812 bfd_fprintf_vma (abfd
, file
, i
->SizeOfInitializedData
);
2813 fprintf (file
, "\nSizeOfUninitializedData\t");
2814 bfd_fprintf_vma (abfd
, file
, i
->SizeOfUninitializedData
);
2815 fprintf (file
, "\nAddressOfEntryPoint\t");
2816 bfd_fprintf_vma (abfd
, file
, i
->AddressOfEntryPoint
);
2817 fprintf (file
, "\nBaseOfCode\t\t");
2818 bfd_fprintf_vma (abfd
, file
, i
->BaseOfCode
);
2819 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
2820 /* PE32+ does not have BaseOfData member! */
2821 fprintf (file
, "\nBaseOfData\t\t");
2822 bfd_fprintf_vma (abfd
, file
, i
->BaseOfData
);
2825 fprintf (file
, "\nImageBase\t\t");
2826 bfd_fprintf_vma (abfd
, file
, i
->ImageBase
);
2827 fprintf (file
, "\nSectionAlignment\t%08x\n", i
->SectionAlignment
);
2828 fprintf (file
, "FileAlignment\t\t%08x\n", i
->FileAlignment
);
2829 fprintf (file
, "MajorOSystemVersion\t%d\n", i
->MajorOperatingSystemVersion
);
2830 fprintf (file
, "MinorOSystemVersion\t%d\n", i
->MinorOperatingSystemVersion
);
2831 fprintf (file
, "MajorImageVersion\t%d\n", i
->MajorImageVersion
);
2832 fprintf (file
, "MinorImageVersion\t%d\n", i
->MinorImageVersion
);
2833 fprintf (file
, "MajorSubsystemVersion\t%d\n", i
->MajorSubsystemVersion
);
2834 fprintf (file
, "MinorSubsystemVersion\t%d\n", i
->MinorSubsystemVersion
);
2835 fprintf (file
, "Win32Version\t\t%08x\n", i
->Reserved1
);
2836 fprintf (file
, "SizeOfImage\t\t%08x\n", i
->SizeOfImage
);
2837 fprintf (file
, "SizeOfHeaders\t\t%08x\n", i
->SizeOfHeaders
);
2838 fprintf (file
, "CheckSum\t\t%08x\n", i
->CheckSum
);
2840 switch (i
->Subsystem
)
2842 case IMAGE_SUBSYSTEM_UNKNOWN
:
2843 subsystem_name
= "unspecified";
2845 case IMAGE_SUBSYSTEM_NATIVE
:
2846 subsystem_name
= "NT native";
2848 case IMAGE_SUBSYSTEM_WINDOWS_GUI
:
2849 subsystem_name
= "Windows GUI";
2851 case IMAGE_SUBSYSTEM_WINDOWS_CUI
:
2852 subsystem_name
= "Windows CUI";
2854 case IMAGE_SUBSYSTEM_POSIX_CUI
:
2855 subsystem_name
= "POSIX CUI";
2857 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI
:
2858 subsystem_name
= "Wince CUI";
2860 /* These are from UEFI Platform Initialization Specification 1.1. */
2861 case IMAGE_SUBSYSTEM_EFI_APPLICATION
:
2862 subsystem_name
= "EFI application";
2864 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
:
2865 subsystem_name
= "EFI boot service driver";
2867 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
:
2868 subsystem_name
= "EFI runtime driver";
2870 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER
:
2871 subsystem_name
= "SAL runtime driver";
2873 /* This is from revision 8.0 of the MS PE/COFF spec */
2874 case IMAGE_SUBSYSTEM_XBOX
:
2875 subsystem_name
= "XBOX";
2877 /* Added default case for clarity - subsystem_name is NULL anyway. */
2879 subsystem_name
= NULL
;
2882 fprintf (file
, "Subsystem\t\t%08x", i
->Subsystem
);
2884 fprintf (file
, "\t(%s)", subsystem_name
);
2885 fprintf (file
, "\nDllCharacteristics\t%08x\n", i
->DllCharacteristics
);
2886 if (i
->DllCharacteristics
)
2888 unsigned short dllch
= i
->DllCharacteristics
;
2889 const char *indent
= "\t\t\t\t\t";
2891 if (dllch
& IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA
)
2892 fprintf (file
, "%sHIGH_ENTROPY_VA\n", indent
);
2893 if (dllch
& IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE
)
2894 fprintf (file
, "%sDYNAMIC_BASE\n", indent
);
2895 if (dllch
& IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY
)
2896 fprintf (file
, "%sFORCE_INTEGRITY\n", indent
);
2897 if (dllch
& IMAGE_DLL_CHARACTERISTICS_NX_COMPAT
)
2898 fprintf (file
, "%sNX_COMPAT\n", indent
);
2899 if (dllch
& IMAGE_DLLCHARACTERISTICS_NO_ISOLATION
)
2900 fprintf (file
, "%sNO_ISOLATION\n", indent
);
2901 if (dllch
& IMAGE_DLLCHARACTERISTICS_NO_SEH
)
2902 fprintf (file
, "%sNO_SEH\n", indent
);
2903 if (dllch
& IMAGE_DLLCHARACTERISTICS_NO_BIND
)
2904 fprintf (file
, "%sNO_BIND\n", indent
);
2905 if (dllch
& IMAGE_DLLCHARACTERISTICS_APPCONTAINER
)
2906 fprintf (file
, "%sAPPCONTAINER\n", indent
);
2907 if (dllch
& IMAGE_DLLCHARACTERISTICS_WDM_DRIVER
)
2908 fprintf (file
, "%sWDM_DRIVER\n", indent
);
2909 if (dllch
& IMAGE_DLLCHARACTERISTICS_GUARD_CF
)
2910 fprintf (file
, "%sGUARD_CF\n", indent
);
2911 if (dllch
& IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE
)
2912 fprintf (file
, "%sTERMINAL_SERVICE_AWARE\n", indent
);
2914 fprintf (file
, "SizeOfStackReserve\t");
2915 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackReserve
);
2916 fprintf (file
, "\nSizeOfStackCommit\t");
2917 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackCommit
);
2918 fprintf (file
, "\nSizeOfHeapReserve\t");
2919 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapReserve
);
2920 fprintf (file
, "\nSizeOfHeapCommit\t");
2921 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapCommit
);
2922 fprintf (file
, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i
->LoaderFlags
);
2923 fprintf (file
, "NumberOfRvaAndSizes\t%08lx\n",
2924 (unsigned long) i
->NumberOfRvaAndSizes
);
2926 fprintf (file
, "\nThe Data Directory\n");
2927 for (j
= 0; j
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; j
++)
2929 fprintf (file
, "Entry %1x ", j
);
2930 bfd_fprintf_vma (abfd
, file
, i
->DataDirectory
[j
].VirtualAddress
);
2931 fprintf (file
, " %08lx ", (unsigned long) i
->DataDirectory
[j
].Size
);
2932 fprintf (file
, "%s\n", dir_names
[j
]);
2935 pe_print_idata (abfd
, vfile
);
2936 pe_print_edata (abfd
, vfile
);
2937 if (bfd_coff_have_print_pdata (abfd
))
2938 bfd_coff_print_pdata (abfd
, vfile
);
2940 pe_print_pdata (abfd
, vfile
);
2941 pe_print_reloc (abfd
, vfile
);
2942 pe_print_debugdata (abfd
, file
);
2944 rsrc_print_section (abfd
, vfile
);
2950 is_vma_in_section (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sect
, void *obj
)
2952 bfd_vma addr
= * (bfd_vma
*) obj
;
2953 return (addr
>= sect
->vma
) && (addr
< (sect
->vma
+ sect
->size
));
2957 find_section_by_vma (bfd
*abfd
, bfd_vma addr
)
2959 return bfd_sections_find_if (abfd
, is_vma_in_section
, (void *) & addr
);
2962 /* Copy any private info we understand from the input bfd
2963 to the output bfd. */
2966 _bfd_XX_bfd_copy_private_bfd_data_common (bfd
* ibfd
, bfd
* obfd
)
2968 pe_data_type
*ipe
, *ope
;
2971 /* One day we may try to grok other private data. */
2972 if (ibfd
->xvec
->flavour
!= bfd_target_coff_flavour
2973 || obfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
2976 ipe
= pe_data (ibfd
);
2977 ope
= pe_data (obfd
);
2979 /* pe_opthdr is copied in copy_object. */
2980 ope
->dll
= ipe
->dll
;
2982 /* Don't copy input subsystem if output is different from input. */
2983 if (obfd
->xvec
!= ibfd
->xvec
)
2984 ope
->pe_opthdr
.Subsystem
= IMAGE_SUBSYSTEM_UNKNOWN
;
2986 /* For strip: if we removed .reloc, we'll make a real mess of things
2987 if we don't remove this entry as well. */
2988 if (! pe_data (obfd
)->has_reloc_section
)
2990 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].VirtualAddress
= 0;
2991 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].Size
= 0;
2994 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2995 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2997 if (! pe_data (ibfd
)->has_reloc_section
2998 && ! (pe_data (ibfd
)->real_flags
& IMAGE_FILE_RELOCS_STRIPPED
))
2999 pe_data (obfd
)->dont_strip_reloc
= 1;
3001 memcpy (ope
->dos_message
, ipe
->dos_message
, sizeof (ope
->dos_message
));
3003 /* The file offsets contained in the debug directory need rewriting. */
3004 size
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
;
3007 bfd_vma addr
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
3008 + ope
->pe_opthdr
.ImageBase
;
3009 /* In particular a .buildid section may overlap (in VA space) with
3010 whatever section comes ahead of it (largely because of section->size
3011 representing s_size, not virt_size). Therefore don't look for the
3012 section containing the first byte, but for that covering the last
3014 bfd_vma last
= addr
+ size
- 1;
3015 asection
*section
= find_section_by_vma (obfd
, last
);
3017 if (section
!= NULL
)
3020 bfd_vma dataoff
= addr
- section
->vma
;
3022 /* PR 17512: file: 0f15796a. */
3023 if (addr
< section
->vma
3024 || section
->size
< dataoff
3025 || section
->size
- dataoff
< size
)
3027 /* xgettext:c-format */
3029 (_("%pB: Data Directory (%lx bytes at %" PRIx64
") "
3030 "extends across section boundary at %" PRIx64
),
3031 obfd
, ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
,
3032 (uint64_t) addr
, (uint64_t) section
->vma
);
3036 if ((section
->flags
& SEC_HAS_CONTENTS
) != 0
3037 && bfd_malloc_and_get_section (obfd
, section
, &data
))
3040 struct external_IMAGE_DEBUG_DIRECTORY
*dd
=
3041 (struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
);
3043 for (i
= 0; i
< ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
3044 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
3046 asection
*ddsection
;
3047 struct external_IMAGE_DEBUG_DIRECTORY
*edd
= &(dd
[i
]);
3048 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
3051 _bfd_XXi_swap_debugdir_in (obfd
, edd
, &idd
);
3053 /* RVA 0 means only offset is valid, not handled yet. */
3054 if (idd
.AddressOfRawData
== 0)
3057 idd_vma
= idd
.AddressOfRawData
+ ope
->pe_opthdr
.ImageBase
;
3058 ddsection
= find_section_by_vma (obfd
, idd_vma
);
3060 continue; /* Not in a section! */
3062 idd
.PointerToRawData
3063 = ddsection
->filepos
+ idd_vma
- ddsection
->vma
;
3064 _bfd_XXi_swap_debugdir_out (obfd
, &idd
, edd
);
3067 if (!bfd_set_section_contents (obfd
, section
, data
, 0,
3070 _bfd_error_handler (_("failed to update file offsets"
3071 " in debug directory"));
3079 _bfd_error_handler (_("%pB: failed to read "
3080 "debug data section"), obfd
);
3089 /* Copy private section data. */
3092 _bfd_XX_bfd_copy_private_section_data (bfd
*ibfd
,
3097 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
3098 || bfd_get_flavour (obfd
) != bfd_target_coff_flavour
)
3101 if (coff_section_data (ibfd
, isec
) != NULL
3102 && pei_section_data (ibfd
, isec
) != NULL
)
3104 if (coff_section_data (obfd
, osec
) == NULL
)
3106 size_t amt
= sizeof (struct coff_section_tdata
);
3107 osec
->used_by_bfd
= bfd_zalloc (obfd
, amt
);
3108 if (osec
->used_by_bfd
== NULL
)
3112 if (pei_section_data (obfd
, osec
) == NULL
)
3114 size_t amt
= sizeof (struct pei_section_tdata
);
3115 coff_section_data (obfd
, osec
)->tdata
= bfd_zalloc (obfd
, amt
);
3116 if (coff_section_data (obfd
, osec
)->tdata
== NULL
)
3120 pei_section_data (obfd
, osec
)->virt_size
=
3121 pei_section_data (ibfd
, isec
)->virt_size
;
3122 pei_section_data (obfd
, osec
)->pe_flags
=
3123 pei_section_data (ibfd
, isec
)->pe_flags
;
3130 _bfd_XX_get_symbol_info (bfd
* abfd
, asymbol
*symbol
, symbol_info
*ret
)
3132 coff_get_symbol_info (abfd
, symbol
, ret
);
3135 #if !defined(COFF_WITH_pep) && (defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64))
3137 sort_x64_pdata (const void *l
, const void *r
)
3139 const char *lp
= (const char *) l
;
3140 const char *rp
= (const char *) r
;
3142 vl
= bfd_getl32 (lp
); vr
= bfd_getl32 (rp
);
3144 return (vl
< vr
? -1 : 1);
3145 /* We compare just begin address. */
3150 /* Functions to process a .rsrc section. */
3152 static unsigned int sizeof_leaves
;
3153 static unsigned int sizeof_strings
;
3154 static unsigned int sizeof_tables_and_entries
;
3157 rsrc_count_directory (bfd
*, bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
3160 rsrc_count_entries (bfd
*abfd
,
3162 bfd_byte
*datastart
,
3167 unsigned long entry
, addr
, size
;
3169 if (data
+ 8 >= dataend
)
3176 entry
= (long) bfd_get_32 (abfd
, data
);
3178 if (HighBitSet (entry
))
3179 name
= datastart
+ WithoutHighBit (entry
);
3181 name
= datastart
+ entry
- rva_bias
;
3183 if (name
+ 2 >= dataend
|| name
< datastart
)
3186 unsigned int len
= bfd_get_16 (abfd
, name
);
3187 if (len
== 0 || len
> 256)
3191 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
3193 if (HighBitSet (entry
))
3195 data
= datastart
+ WithoutHighBit (entry
);
3197 if (data
<= datastart
|| data
>= dataend
)
3200 return rsrc_count_directory (abfd
, datastart
, data
, dataend
, rva_bias
);
3203 if (datastart
+ entry
+ 16 >= dataend
)
3206 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
);
3207 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4);
3209 return datastart
+ addr
- rva_bias
+ size
;
3213 rsrc_count_directory (bfd
* abfd
,
3214 bfd_byte
* datastart
,
3219 unsigned int num_entries
, num_ids
;
3220 bfd_byte
* highest_data
= data
;
3222 if (data
+ 16 >= dataend
)
3225 num_entries
= (int) bfd_get_16 (abfd
, data
+ 12);
3226 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14);
3228 num_entries
+= num_ids
;
3232 while (num_entries
--)
3234 bfd_byte
* entry_end
;
3236 entry_end
= rsrc_count_entries (abfd
, num_entries
>= num_ids
,
3237 datastart
, data
, dataend
, rva_bias
);
3239 highest_data
= max (highest_data
, entry_end
);
3240 if (entry_end
>= dataend
)
3244 return max (highest_data
, data
);
3247 typedef struct rsrc_dir_chain
3249 unsigned int num_entries
;
3250 struct rsrc_entry
* first_entry
;
3251 struct rsrc_entry
* last_entry
;
3254 typedef struct rsrc_directory
3256 unsigned int characteristics
;
3261 rsrc_dir_chain names
;
3264 struct rsrc_entry
* entry
;
3267 typedef struct rsrc_string
3273 typedef struct rsrc_leaf
3276 unsigned int codepage
;
3280 typedef struct rsrc_entry
3286 struct rsrc_string name
;
3292 struct rsrc_directory
* directory
;
3293 struct rsrc_leaf
* leaf
;
3296 struct rsrc_entry
* next_entry
;
3297 struct rsrc_directory
* parent
;
3301 rsrc_parse_directory (bfd
*, rsrc_directory
*, bfd_byte
*,
3302 bfd_byte
*, bfd_byte
*, bfd_vma
, rsrc_entry
*);
3305 rsrc_parse_entry (bfd
*abfd
,
3308 bfd_byte
*datastart
,
3312 rsrc_directory
*parent
)
3314 unsigned long val
, addr
, size
;
3316 val
= bfd_get_32 (abfd
, data
);
3318 entry
->parent
= parent
;
3319 entry
->is_name
= is_name
;
3325 if (HighBitSet (val
))
3327 val
= WithoutHighBit (val
);
3329 address
= datastart
+ val
;
3333 address
= datastart
+ val
- rva_bias
;
3336 if (address
+ 3 > dataend
)
3339 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, address
);
3340 entry
->name_id
.name
.string
= address
+ 2;
3343 entry
->name_id
.id
= val
;
3345 val
= bfd_get_32 (abfd
, data
+ 4);
3347 if (HighBitSet (val
))
3349 entry
->is_dir
= true;
3350 entry
->value
.directory
= bfd_malloc (sizeof (*entry
->value
.directory
));
3351 if (entry
->value
.directory
== NULL
)
3354 return rsrc_parse_directory (abfd
, entry
->value
.directory
,
3356 datastart
+ WithoutHighBit (val
),
3357 dataend
, rva_bias
, entry
);
3360 entry
->is_dir
= false;
3361 entry
->value
.leaf
= bfd_malloc (sizeof (*entry
->value
.leaf
));
3362 if (entry
->value
.leaf
== NULL
)
3365 data
= datastart
+ val
;
3366 if (data
< datastart
|| data
+ 12 > dataend
)
3369 addr
= bfd_get_32 (abfd
, data
);
3370 size
= entry
->value
.leaf
->size
= bfd_get_32 (abfd
, data
+ 4);
3371 entry
->value
.leaf
->codepage
= bfd_get_32 (abfd
, data
+ 8);
3372 /* FIXME: We assume that the reserved field (data + 12) is OK. */
3374 if (size
> dataend
- datastart
- (addr
- rva_bias
))
3376 entry
->value
.leaf
->data
= bfd_malloc (size
);
3377 if (entry
->value
.leaf
->data
== NULL
)
3380 memcpy (entry
->value
.leaf
->data
, datastart
+ addr
- rva_bias
, size
);
3381 return datastart
+ (addr
- rva_bias
) + size
;
3385 rsrc_parse_entries (bfd
*abfd
,
3386 rsrc_dir_chain
*chain
,
3388 bfd_byte
*highest_data
,
3389 bfd_byte
*datastart
,
3393 rsrc_directory
*parent
)
3398 if (chain
->num_entries
== 0)
3400 chain
->first_entry
= chain
->last_entry
= NULL
;
3401 return highest_data
;
3404 entry
= bfd_malloc (sizeof (*entry
));
3408 chain
->first_entry
= entry
;
3410 for (i
= chain
->num_entries
; i
--;)
3412 bfd_byte
* entry_end
;
3414 entry_end
= rsrc_parse_entry (abfd
, is_name
, entry
, datastart
,
3415 data
, dataend
, rva_bias
, parent
);
3417 highest_data
= max (entry_end
, highest_data
);
3418 if (entry_end
> dataend
)
3423 entry
->next_entry
= bfd_malloc (sizeof (*entry
));
3424 entry
= entry
->next_entry
;
3429 entry
->next_entry
= NULL
;
3432 chain
->last_entry
= entry
;
3434 return highest_data
;
3438 rsrc_parse_directory (bfd
* abfd
,
3439 rsrc_directory
* table
,
3440 bfd_byte
* datastart
,
3446 bfd_byte
* highest_data
= data
;
3451 table
->characteristics
= bfd_get_32 (abfd
, data
);
3452 table
->time
= bfd_get_32 (abfd
, data
+ 4);
3453 table
->major
= bfd_get_16 (abfd
, data
+ 8);
3454 table
->minor
= bfd_get_16 (abfd
, data
+ 10);
3455 table
->names
.num_entries
= bfd_get_16 (abfd
, data
+ 12);
3456 table
->ids
.num_entries
= bfd_get_16 (abfd
, data
+ 14);
3457 table
->entry
= entry
;
3461 highest_data
= rsrc_parse_entries (abfd
, & table
->names
, true, data
,
3462 datastart
, data
, dataend
, rva_bias
, table
);
3463 data
+= table
->names
.num_entries
* 8;
3465 highest_data
= rsrc_parse_entries (abfd
, & table
->ids
, false, highest_data
,
3466 datastart
, data
, dataend
, rva_bias
, table
);
3467 data
+= table
->ids
.num_entries
* 8;
3469 return max (highest_data
, data
);
3472 typedef struct rsrc_write_data
3475 bfd_byte
* datastart
;
3476 bfd_byte
* next_table
;
3477 bfd_byte
* next_leaf
;
3478 bfd_byte
* next_string
;
3479 bfd_byte
* next_data
;
3484 rsrc_write_string (rsrc_write_data
* data
,
3485 rsrc_string
* string
)
3487 bfd_put_16 (data
->abfd
, string
->len
, data
->next_string
);
3488 memcpy (data
->next_string
+ 2, string
->string
, string
->len
* 2);
3489 data
->next_string
+= (string
->len
+ 1) * 2;
3492 static inline unsigned int
3493 rsrc_compute_rva (rsrc_write_data
* data
,
3496 return (addr
- data
->datastart
) + data
->rva_bias
;
3500 rsrc_write_leaf (rsrc_write_data
* data
,
3503 bfd_put_32 (data
->abfd
, rsrc_compute_rva (data
, data
->next_data
),
3505 bfd_put_32 (data
->abfd
, leaf
->size
, data
->next_leaf
+ 4);
3506 bfd_put_32 (data
->abfd
, leaf
->codepage
, data
->next_leaf
+ 8);
3507 bfd_put_32 (data
->abfd
, 0 /*reserved*/, data
->next_leaf
+ 12);
3508 data
->next_leaf
+= 16;
3510 memcpy (data
->next_data
, leaf
->data
, leaf
->size
);
3511 /* An undocumented feature of Windows resources is that each unit
3512 of raw data is 8-byte aligned... */
3513 data
->next_data
+= ((leaf
->size
+ 7) & ~7);
3516 static void rsrc_write_directory (rsrc_write_data
*, rsrc_directory
*);
3519 rsrc_write_entry (rsrc_write_data
* data
,
3525 bfd_put_32 (data
->abfd
,
3526 SetHighBit (data
->next_string
- data
->datastart
),
3528 rsrc_write_string (data
, & entry
->name_id
.name
);
3531 bfd_put_32 (data
->abfd
, entry
->name_id
.id
, where
);
3535 bfd_put_32 (data
->abfd
,
3536 SetHighBit (data
->next_table
- data
->datastart
),
3538 rsrc_write_directory (data
, entry
->value
.directory
);
3542 bfd_put_32 (data
->abfd
, data
->next_leaf
- data
->datastart
, where
+ 4);
3543 rsrc_write_leaf (data
, entry
->value
.leaf
);
3548 rsrc_compute_region_sizes (rsrc_directory
* dir
)
3550 struct rsrc_entry
* entry
;
3555 sizeof_tables_and_entries
+= 16;
3557 for (entry
= dir
->names
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3559 sizeof_tables_and_entries
+= 8;
3561 sizeof_strings
+= (entry
->name_id
.name
.len
+ 1) * 2;
3564 rsrc_compute_region_sizes (entry
->value
.directory
);
3566 sizeof_leaves
+= 16;
3569 for (entry
= dir
->ids
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3571 sizeof_tables_and_entries
+= 8;
3574 rsrc_compute_region_sizes (entry
->value
.directory
);
3576 sizeof_leaves
+= 16;
3581 rsrc_write_directory (rsrc_write_data
* data
,
3582 rsrc_directory
* dir
)
3586 bfd_byte
* next_entry
;
3589 bfd_put_32 (data
->abfd
, dir
->characteristics
, data
->next_table
);
3590 bfd_put_32 (data
->abfd
, 0 /*dir->time*/, data
->next_table
+ 4);
3591 bfd_put_16 (data
->abfd
, dir
->major
, data
->next_table
+ 8);
3592 bfd_put_16 (data
->abfd
, dir
->minor
, data
->next_table
+ 10);
3593 bfd_put_16 (data
->abfd
, dir
->names
.num_entries
, data
->next_table
+ 12);
3594 bfd_put_16 (data
->abfd
, dir
->ids
.num_entries
, data
->next_table
+ 14);
3596 /* Compute where the entries and the next table will be placed. */
3597 next_entry
= data
->next_table
+ 16;
3598 data
->next_table
= next_entry
+ (dir
->names
.num_entries
* 8)
3599 + (dir
->ids
.num_entries
* 8);
3600 nt
= data
->next_table
;
3602 /* Write the entries. */
3603 for (i
= dir
->names
.num_entries
, entry
= dir
->names
.first_entry
;
3604 i
> 0 && entry
!= NULL
;
3605 i
--, entry
= entry
->next_entry
)
3607 BFD_ASSERT (entry
->is_name
);
3608 rsrc_write_entry (data
, next_entry
, entry
);
3611 BFD_ASSERT (i
== 0);
3612 BFD_ASSERT (entry
== NULL
);
3614 for (i
= dir
->ids
.num_entries
, entry
= dir
->ids
.first_entry
;
3615 i
> 0 && entry
!= NULL
;
3616 i
--, entry
= entry
->next_entry
)
3618 BFD_ASSERT (! entry
->is_name
);
3619 rsrc_write_entry (data
, next_entry
, entry
);
3622 BFD_ASSERT (i
== 0);
3623 BFD_ASSERT (entry
== NULL
);
3624 BFD_ASSERT (nt
== next_entry
);
3627 #if ! defined __CYGWIN__ && ! defined __MINGW32__
3628 /* Return the length (number of units) of the first character in S,
3629 putting its 'ucs4_t' representation in *PUC. */
3632 u16_mbtouc (wint_t * puc
, const unsigned short * s
, unsigned int n
)
3634 unsigned short c
= * s
;
3636 if (c
< 0xd800 || c
>= 0xe000)
3646 if (s
[1] >= 0xdc00 && s
[1] < 0xe000)
3648 *puc
= 0x10000 + ((c
- 0xd800) << 10) + (s
[1] - 0xdc00);
3654 /* Incomplete multibyte character. */
3660 /* Invalid multibyte character. */
3664 #endif /* not Cygwin/Mingw */
3666 /* Perform a comparison of two entries. */
3668 rsrc_cmp (bool is_name
, rsrc_entry
* a
, rsrc_entry
* b
)
3677 return a
->name_id
.id
- b
->name_id
.id
;
3679 /* We have to perform a case insenstive, unicode string comparison... */
3680 astring
= a
->name_id
.name
.string
;
3681 alen
= a
->name_id
.name
.len
;
3682 bstring
= b
->name_id
.name
.string
;
3683 blen
= b
->name_id
.name
.len
;
3685 #if defined __CYGWIN__ || defined __MINGW32__
3686 /* Under Windows hosts (both Cygwin and Mingw types),
3687 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3688 function however goes by different names in the two environments... */
3692 #define rscpcmp wcsncasecmp
3695 #define rscpcmp wcsnicmp
3698 res
= rscpcmp ((const wchar_t *) astring
, (const wchar_t *) bstring
,
3706 for (i
= min (alen
, blen
); i
--; astring
+= 2, bstring
+= 2)
3711 /* Convert UTF-16 unicode characters into wchar_t characters
3712 so that we can then perform a case insensitive comparison. */
3713 unsigned int Alen
= u16_mbtouc (& awc
, (const unsigned short *) astring
, 2);
3714 unsigned int Blen
= u16_mbtouc (& bwc
, (const unsigned short *) bstring
, 2);
3719 awc
= towlower (awc
);
3720 bwc
= towlower (bwc
);
3736 rsrc_print_name (char * buffer
, rsrc_string string
)
3739 bfd_byte
* name
= string
.string
;
3741 for (i
= string
.len
; i
--; name
+= 2)
3742 sprintf (buffer
+ strlen (buffer
), "%.1s", name
);
3746 rsrc_resource_name (rsrc_entry
*entry
, rsrc_directory
*dir
, char *buffer
)
3748 bool is_string
= false;
3752 if (dir
!= NULL
&& dir
->entry
!= NULL
&& dir
->entry
->parent
!= NULL
3753 && dir
->entry
->parent
->entry
!= NULL
)
3755 strcpy (buffer
, "type: ");
3756 if (dir
->entry
->parent
->entry
->is_name
)
3757 rsrc_print_name (buffer
+ strlen (buffer
),
3758 dir
->entry
->parent
->entry
->name_id
.name
);
3761 unsigned int id
= dir
->entry
->parent
->entry
->name_id
.id
;
3763 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3766 case 1: strcat (buffer
, " (CURSOR)"); break;
3767 case 2: strcat (buffer
, " (BITMAP)"); break;
3768 case 3: strcat (buffer
, " (ICON)"); break;
3769 case 4: strcat (buffer
, " (MENU)"); break;
3770 case 5: strcat (buffer
, " (DIALOG)"); break;
3771 case 6: strcat (buffer
, " (STRING)"); is_string
= true; break;
3772 case 7: strcat (buffer
, " (FONTDIR)"); break;
3773 case 8: strcat (buffer
, " (FONT)"); break;
3774 case 9: strcat (buffer
, " (ACCELERATOR)"); break;
3775 case 10: strcat (buffer
, " (RCDATA)"); break;
3776 case 11: strcat (buffer
, " (MESSAGETABLE)"); break;
3777 case 12: strcat (buffer
, " (GROUP_CURSOR)"); break;
3778 case 14: strcat (buffer
, " (GROUP_ICON)"); break;
3779 case 16: strcat (buffer
, " (VERSION)"); break;
3780 case 17: strcat (buffer
, " (DLGINCLUDE)"); break;
3781 case 19: strcat (buffer
, " (PLUGPLAY)"); break;
3782 case 20: strcat (buffer
, " (VXD)"); break;
3783 case 21: strcat (buffer
, " (ANICURSOR)"); break;
3784 case 22: strcat (buffer
, " (ANIICON)"); break;
3785 case 23: strcat (buffer
, " (HTML)"); break;
3786 case 24: strcat (buffer
, " (MANIFEST)"); break;
3787 case 240: strcat (buffer
, " (DLGINIT)"); break;
3788 case 241: strcat (buffer
, " (TOOLBAR)"); break;
3793 if (dir
!= NULL
&& dir
->entry
!= NULL
)
3795 strcat (buffer
, " name: ");
3796 if (dir
->entry
->is_name
)
3797 rsrc_print_name (buffer
+ strlen (buffer
), dir
->entry
->name_id
.name
);
3800 unsigned int id
= dir
->entry
->name_id
.id
;
3802 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3805 sprintf (buffer
+ strlen (buffer
), " (resource id range: %d - %d)",
3806 (id
- 1) << 4, (id
<< 4) - 1);
3812 strcat (buffer
, " lang: ");
3815 rsrc_print_name (buffer
+ strlen (buffer
), entry
->name_id
.name
);
3817 sprintf (buffer
+ strlen (buffer
), "%x", entry
->name_id
.id
);
3823 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3824 their ID is stored in the NAME entry. The bottom four bits are used as
3825 an index into unicode string table that makes up the data of the leaf.
3826 So identical type-name-lang string resources may not actually be
3829 This function is called when we have detected two string resources with
3830 match top-28-bit IDs. We have to scan the string tables inside the leaves
3831 and discover if there are any real collisions. If there are then we report
3832 them and return FALSE. Otherwise we copy any strings from B into A and
3833 then return TRUE. */
3836 rsrc_merge_string_entries (rsrc_entry
* a ATTRIBUTE_UNUSED
,
3837 rsrc_entry
* b ATTRIBUTE_UNUSED
)
3839 unsigned int copy_needed
= 0;
3843 bfd_byte
* new_data
;
3846 /* Step one: Find out what we have to do. */
3847 BFD_ASSERT (! a
->is_dir
);
3848 astring
= a
->value
.leaf
->data
;
3850 BFD_ASSERT (! b
->is_dir
);
3851 bstring
= b
->value
.leaf
->data
;
3853 for (i
= 0; i
< 16; i
++)
3855 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3856 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3860 copy_needed
+= blen
* 2;
3864 else if (alen
!= blen
)
3865 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3867 /* alen == blen != 0. We might have two identical strings. If so we
3868 can ignore the second one. There is no need for wchar_t vs UTF-16
3869 theatrics here - we are only interested in (case sensitive) equality. */
3870 else if (memcmp (astring
+ 2, bstring
+ 2, alen
* 2) != 0)
3873 astring
+= (alen
+ 1) * 2;
3874 bstring
+= (blen
+ 1) * 2;
3879 if (a
->parent
!= NULL
3880 && a
->parent
->entry
!= NULL
3881 && !a
->parent
->entry
->is_name
)
3882 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3883 ((a
->parent
->entry
->name_id
.id
- 1) << 4) + i
);
3887 if (copy_needed
== 0)
3890 /* If we reach here then A and B must both have non-colliding strings.
3891 (We never get string resources with fully empty string tables).
3892 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3894 new_data
= bfd_malloc (a
->value
.leaf
->size
+ copy_needed
);
3895 if (new_data
== NULL
)
3899 astring
= a
->value
.leaf
->data
;
3900 bstring
= b
->value
.leaf
->data
;
3902 for (i
= 0; i
< 16; i
++)
3904 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3905 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3909 memcpy (nstring
, astring
, (alen
+ 1) * 2);
3910 nstring
+= (alen
+ 1) * 2;
3914 memcpy (nstring
, bstring
, (blen
+ 1) * 2);
3915 nstring
+= (blen
+ 1) * 2;
3923 astring
+= (alen
+ 1) * 2;
3924 bstring
+= (blen
+ 1) * 2;
3927 BFD_ASSERT (nstring
- new_data
== (signed) (a
->value
.leaf
->size
+ copy_needed
));
3929 free (a
->value
.leaf
->data
);
3930 a
->value
.leaf
->data
= new_data
;
3931 a
->value
.leaf
->size
+= copy_needed
;
3936 static void rsrc_merge (rsrc_entry
*, rsrc_entry
*);
3938 /* Sort the entries in given part of the directory.
3939 We use an old fashioned bubble sort because we are dealing
3940 with lists and we want to handle matches specially. */
3943 rsrc_sort_entries (rsrc_dir_chain
*chain
,
3945 rsrc_directory
*dir
)
3949 rsrc_entry
** points_to_entry
;
3952 if (chain
->num_entries
< 2)
3958 points_to_entry
= & chain
->first_entry
;
3959 entry
= * points_to_entry
;
3960 next
= entry
->next_entry
;
3964 signed int cmp
= rsrc_cmp (is_name
, entry
, next
);
3968 entry
->next_entry
= next
->next_entry
;
3969 next
->next_entry
= entry
;
3970 * points_to_entry
= next
;
3971 points_to_entry
= & next
->next_entry
;
3972 next
= entry
->next_entry
;
3977 if (entry
->is_dir
&& next
->is_dir
)
3979 /* When we encounter identical directory entries we have to
3980 merge them together. The exception to this rule is for
3981 resource manifests - there can only be one of these,
3982 even if they differ in language. Zero-language manifests
3983 are assumed to be default manifests (provided by the
3984 Cygwin/MinGW build system) and these can be silently dropped,
3985 unless that would reduce the number of manifests to zero.
3986 There should only ever be one non-zero lang manifest -
3987 if there are more it is an error. A non-zero lang
3988 manifest takes precedence over a default manifest. */
3990 && entry
->name_id
.id
== 1
3992 && dir
->entry
!= NULL
3993 && !dir
->entry
->is_name
3994 && dir
->entry
->name_id
.id
== 0x18)
3996 if (next
->value
.directory
->names
.num_entries
== 0
3997 && next
->value
.directory
->ids
.num_entries
== 1
3998 && !next
->value
.directory
->ids
.first_entry
->is_name
3999 && next
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
4000 /* Fall through so that NEXT is dropped. */
4002 else if (entry
->value
.directory
->names
.num_entries
== 0
4003 && entry
->value
.directory
->ids
.num_entries
== 1
4004 && !entry
->value
.directory
->ids
.first_entry
->is_name
4005 && entry
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
4007 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
4008 entry
->next_entry
= next
->next_entry
;
4009 next
->next_entry
= entry
;
4010 * points_to_entry
= next
;
4011 points_to_entry
= & next
->next_entry
;
4012 next
= entry
->next_entry
;
4017 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
4018 bfd_set_error (bfd_error_file_truncated
);
4022 /* Unhook NEXT from the chain. */
4023 /* FIXME: memory loss here. */
4024 entry
->next_entry
= next
->next_entry
;
4025 chain
->num_entries
--;
4026 if (chain
->num_entries
< 2)
4028 next
= next
->next_entry
;
4031 rsrc_merge (entry
, next
);
4033 else if (entry
->is_dir
!= next
->is_dir
)
4035 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
4036 bfd_set_error (bfd_error_file_truncated
);
4041 /* Otherwise with identical leaves we issue an error
4042 message - because there should never be duplicates.
4043 The exception is Type 18/Name 1/Lang 0 which is the
4044 defaul manifest - this can just be dropped. */
4046 && entry
->name_id
.id
== 0
4048 && dir
->entry
!= NULL
4049 && !dir
->entry
->is_name
4050 && dir
->entry
->name_id
.id
== 1
4051 && dir
->entry
->parent
!= NULL
4052 && dir
->entry
->parent
->entry
!= NULL
4053 && !dir
->entry
->parent
->entry
->is_name
4054 && dir
->entry
->parent
->entry
->name_id
.id
== 0x18 /* RT_MANIFEST */)
4056 else if (dir
!= NULL
4057 && dir
->entry
!= NULL
4058 && dir
->entry
->parent
!= NULL
4059 && dir
->entry
->parent
->entry
!= NULL
4060 && !dir
->entry
->parent
->entry
->is_name
4061 && dir
->entry
->parent
->entry
->name_id
.id
== 0x6 /* RT_STRING */)
4063 /* Strings need special handling. */
4064 if (! rsrc_merge_string_entries (entry
, next
))
4066 /* _bfd_error_handler should have been called inside merge_strings. */
4067 bfd_set_error (bfd_error_file_truncated
);
4074 || dir
->entry
== NULL
4075 || dir
->entry
->parent
== NULL
4076 || dir
->entry
->parent
->entry
== NULL
)
4077 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
4082 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
4083 rsrc_resource_name (entry
, dir
, buff
));
4085 bfd_set_error (bfd_error_file_truncated
);
4090 /* Unhook NEXT from the chain. */
4091 entry
->next_entry
= next
->next_entry
;
4092 chain
->num_entries
--;
4093 if (chain
->num_entries
< 2)
4095 next
= next
->next_entry
;
4099 points_to_entry
= & entry
->next_entry
;
4101 next
= next
->next_entry
;
4106 chain
->last_entry
= entry
;
4111 /* Attach B's chain onto A. */
4113 rsrc_attach_chain (rsrc_dir_chain
* achain
, rsrc_dir_chain
* bchain
)
4115 if (bchain
->num_entries
== 0)
4118 achain
->num_entries
+= bchain
->num_entries
;
4120 if (achain
->first_entry
== NULL
)
4122 achain
->first_entry
= bchain
->first_entry
;
4123 achain
->last_entry
= bchain
->last_entry
;
4127 achain
->last_entry
->next_entry
= bchain
->first_entry
;
4128 achain
->last_entry
= bchain
->last_entry
;
4131 bchain
->num_entries
= 0;
4132 bchain
->first_entry
= bchain
->last_entry
= NULL
;
4136 rsrc_merge (struct rsrc_entry
* a
, struct rsrc_entry
* b
)
4138 rsrc_directory
* adir
;
4139 rsrc_directory
* bdir
;
4141 BFD_ASSERT (a
->is_dir
);
4142 BFD_ASSERT (b
->is_dir
);
4144 adir
= a
->value
.directory
;
4145 bdir
= b
->value
.directory
;
4147 if (adir
->characteristics
!= bdir
->characteristics
)
4149 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics"));
4150 bfd_set_error (bfd_error_file_truncated
);
4154 if (adir
->major
!= bdir
->major
|| adir
->minor
!= bdir
->minor
)
4156 _bfd_error_handler (_(".rsrc merge failure: differing directory versions"));
4157 bfd_set_error (bfd_error_file_truncated
);
4161 /* Attach B's name chain to A. */
4162 rsrc_attach_chain (& adir
->names
, & bdir
->names
);
4164 /* Attach B's ID chain to A. */
4165 rsrc_attach_chain (& adir
->ids
, & bdir
->ids
);
4167 /* Now sort A's entries. */
4168 rsrc_sort_entries (& adir
->names
, true, adir
);
4169 rsrc_sort_entries (& adir
->ids
, false, adir
);
4172 /* Check the .rsrc section. If it contains multiple concatenated
4173 resources then we must merge them properly. Otherwise Windows
4174 will ignore all but the first set. */
4177 rsrc_process_section (bfd
* abfd
,
4178 struct coff_final_link_info
* pfinfo
)
4180 rsrc_directory new_table
;
4186 bfd_byte
* datastart
;
4188 bfd_byte
* new_data
;
4189 unsigned int num_resource_sets
;
4190 rsrc_directory
* type_tables
;
4191 rsrc_write_data write_data
;
4194 unsigned int num_input_rsrc
= 0;
4195 unsigned int max_num_input_rsrc
= 4;
4196 ptrdiff_t * rsrc_sizes
= NULL
;
4198 new_table
.names
.num_entries
= 0;
4199 new_table
.ids
.num_entries
= 0;
4201 sec
= bfd_get_section_by_name (abfd
, ".rsrc");
4202 if (sec
== NULL
|| (size
= sec
->rawsize
) == 0)
4205 pe
= pe_data (abfd
);
4209 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4211 if (! bfd_malloc_and_get_section (abfd
, sec
, &datastart
))
4214 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4215 their lengths. Note - we rely upon the fact that the linker script
4216 does *not* sort the input .rsrc sections, so that the order in the
4217 linkinfo list matches the order in the output .rsrc section.
4219 We need to know the lengths because each input .rsrc section has padding
4220 at the end of a variable amount. (It does not appear to be based upon
4221 the section alignment or the file alignment). We need to skip any
4222 padding bytes when parsing the input .rsrc sections. */
4224 rsrc_sizes
= bfd_malloc (max_num_input_rsrc
* sizeof (*rsrc_sizes
));
4225 if (rsrc_sizes
== NULL
)
4228 for (input
= pfinfo
->info
->input_bfds
;
4230 input
= input
->link
.next
)
4232 asection
* rsrc_sec
= bfd_get_section_by_name (input
, ".rsrc");
4234 /* PR 18372 - skip discarded .rsrc sections. */
4235 if (rsrc_sec
!= NULL
&& !discarded_section (rsrc_sec
))
4237 if (num_input_rsrc
== max_num_input_rsrc
)
4239 max_num_input_rsrc
+= 10;
4240 rsrc_sizes
= bfd_realloc (rsrc_sizes
, max_num_input_rsrc
4241 * sizeof (*rsrc_sizes
));
4242 if (rsrc_sizes
== NULL
)
4246 BFD_ASSERT (rsrc_sec
->size
> 0);
4247 rsrc_sizes
[num_input_rsrc
++] = rsrc_sec
->size
;
4251 if (num_input_rsrc
< 2)
4254 /* Step one: Walk the section, computing the size of the tables,
4255 leaves and data and decide if we need to do anything. */
4256 dataend
= data
+ size
;
4257 num_resource_sets
= 0;
4259 while (data
< dataend
)
4261 bfd_byte
* p
= data
;
4263 data
= rsrc_count_directory (abfd
, data
, data
, dataend
, rva_bias
);
4267 /* Corrupted .rsrc section - cannot merge. */
4268 _bfd_error_handler (_("%pB: .rsrc merge failure: corrupt .rsrc section"),
4270 bfd_set_error (bfd_error_file_truncated
);
4274 if ((data
- p
) > rsrc_sizes
[num_resource_sets
])
4276 _bfd_error_handler (_("%pB: .rsrc merge failure: unexpected .rsrc size"),
4278 bfd_set_error (bfd_error_file_truncated
);
4281 /* FIXME: Should we add a check for "data - p" being much smaller
4282 than rsrc_sizes[num_resource_sets] ? */
4284 data
= p
+ rsrc_sizes
[num_resource_sets
];
4285 rva_bias
+= data
- p
;
4286 ++ num_resource_sets
;
4288 BFD_ASSERT (num_resource_sets
== num_input_rsrc
);
4290 /* Step two: Walk the data again, building trees of the resources. */
4292 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4294 type_tables
= bfd_malloc (num_resource_sets
* sizeof (*type_tables
));
4295 if (type_tables
== NULL
)
4299 while (data
< dataend
)
4301 bfd_byte
* p
= data
;
4303 (void) rsrc_parse_directory (abfd
, type_tables
+ indx
, data
, data
,
4304 dataend
, rva_bias
, NULL
);
4305 data
= p
+ rsrc_sizes
[indx
];
4306 rva_bias
+= data
- p
;
4309 BFD_ASSERT (indx
== num_resource_sets
);
4311 /* Step three: Merge the top level tables (there can be only one).
4313 We must ensure that the merged entries are in ascending order.
4315 We also thread the top level table entries from the old tree onto
4316 the new table, so that they can be pulled off later. */
4318 /* FIXME: Should we verify that all type tables are the same ? */
4319 new_table
.characteristics
= type_tables
[0].characteristics
;
4320 new_table
.time
= type_tables
[0].time
;
4321 new_table
.major
= type_tables
[0].major
;
4322 new_table
.minor
= type_tables
[0].minor
;
4324 /* Chain the NAME entries onto the table. */
4325 new_table
.names
.first_entry
= NULL
;
4326 new_table
.names
.last_entry
= NULL
;
4328 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4329 rsrc_attach_chain (& new_table
.names
, & type_tables
[indx
].names
);
4331 rsrc_sort_entries (& new_table
.names
, true, & new_table
);
4333 /* Chain the ID entries onto the table. */
4334 new_table
.ids
.first_entry
= NULL
;
4335 new_table
.ids
.last_entry
= NULL
;
4337 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4338 rsrc_attach_chain (& new_table
.ids
, & type_tables
[indx
].ids
);
4340 rsrc_sort_entries (& new_table
.ids
, false, & new_table
);
4342 /* Step four: Create new contents for the .rsrc section. */
4343 /* Step four point one: Compute the size of each region of the .rsrc section.
4344 We do this now, rather than earlier, as the merging above may have dropped
4346 sizeof_leaves
= sizeof_strings
= sizeof_tables_and_entries
= 0;
4347 rsrc_compute_region_sizes (& new_table
);
4348 /* We increment sizeof_strings to make sure that resource data
4349 starts on an 8-byte boundary. FIXME: Is this correct ? */
4350 sizeof_strings
= (sizeof_strings
+ 7) & ~ 7;
4352 new_data
= bfd_zalloc (abfd
, size
);
4353 if (new_data
== NULL
)
4356 write_data
.abfd
= abfd
;
4357 write_data
.datastart
= new_data
;
4358 write_data
.next_table
= new_data
;
4359 write_data
.next_leaf
= new_data
+ sizeof_tables_and_entries
;
4360 write_data
.next_string
= write_data
.next_leaf
+ sizeof_leaves
;
4361 write_data
.next_data
= write_data
.next_string
+ sizeof_strings
;
4362 write_data
.rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4364 rsrc_write_directory (& write_data
, & new_table
);
4366 /* Step five: Replace the old contents with the new.
4367 We don't recompute the size as it's too late here to shrink section.
4368 See PR ld/20193 for more details. */
4369 bfd_set_section_contents (pfinfo
->output_bfd
, sec
, new_data
, 0, size
);
4370 sec
->size
= sec
->rawsize
= size
;
4373 /* Step six: Free all the memory that we have used. */
4374 /* FIXME: Free the resource tree, if we have one. */
4379 /* Handle the .idata section and other things that need symbol table
4383 _bfd_XXi_final_link_postscript (bfd
* abfd
, struct coff_final_link_info
*pfinfo
)
4385 struct coff_link_hash_entry
*h1
;
4386 struct bfd_link_info
*info
= pfinfo
->info
;
4389 /* There are a few fields that need to be filled in now while we
4390 have symbol table access.
4392 The .idata subsections aren't directly available as sections, but
4393 they are in the symbol table, so get them from there. */
4395 /* The import directory. This is the address of .idata$2, with size
4396 of .idata$2 + .idata$3. */
4397 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4398 ".idata$2", false, false, true);
4401 /* PR ld/2729: We cannot rely upon all the output sections having been
4402 created properly, so check before referencing them. Issue a warning
4403 message for any sections tht could not be found. */
4404 if ((h1
->root
.type
== bfd_link_hash_defined
4405 || h1
->root
.type
== bfd_link_hash_defweak
)
4406 && h1
->root
.u
.def
.section
!= NULL
4407 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4408 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
=
4409 (h1
->root
.u
.def
.value
4410 + h1
->root
.u
.def
.section
->output_section
->vma
4411 + h1
->root
.u
.def
.section
->output_offset
);
4415 (_("%pB: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4420 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4421 ".idata$4", false, false, true);
4423 && (h1
->root
.type
== bfd_link_hash_defined
4424 || h1
->root
.type
== bfd_link_hash_defweak
)
4425 && h1
->root
.u
.def
.section
!= NULL
4426 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4427 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].Size
=
4428 ((h1
->root
.u
.def
.value
4429 + h1
->root
.u
.def
.section
->output_section
->vma
4430 + h1
->root
.u
.def
.section
->output_offset
)
4431 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
);
4435 (_("%pB: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4440 /* The import address table. This is the size/address of
4442 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4443 ".idata$5", false, false, true);
4445 && (h1
->root
.type
== bfd_link_hash_defined
4446 || h1
->root
.type
== bfd_link_hash_defweak
)
4447 && h1
->root
.u
.def
.section
!= NULL
4448 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4449 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4450 (h1
->root
.u
.def
.value
4451 + h1
->root
.u
.def
.section
->output_section
->vma
4452 + h1
->root
.u
.def
.section
->output_offset
);
4456 (_("%pB: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4461 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4462 ".idata$6", false, false, true);
4464 && (h1
->root
.type
== bfd_link_hash_defined
4465 || h1
->root
.type
== bfd_link_hash_defweak
)
4466 && h1
->root
.u
.def
.section
!= NULL
4467 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4468 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4469 ((h1
->root
.u
.def
.value
4470 + h1
->root
.u
.def
.section
->output_section
->vma
4471 + h1
->root
.u
.def
.section
->output_offset
)
4472 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
);
4476 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4483 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4484 "__IAT_start__", false, false, true);
4486 && (h1
->root
.type
== bfd_link_hash_defined
4487 || h1
->root
.type
== bfd_link_hash_defweak
)
4488 && h1
->root
.u
.def
.section
!= NULL
4489 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4494 (h1
->root
.u
.def
.value
4495 + h1
->root
.u
.def
.section
->output_section
->vma
4496 + h1
->root
.u
.def
.section
->output_offset
);
4498 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4499 "__IAT_end__", false, false, true);
4501 && (h1
->root
.type
== bfd_link_hash_defined
4502 || h1
->root
.type
== bfd_link_hash_defweak
)
4503 && h1
->root
.u
.def
.section
!= NULL
4504 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4506 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4507 ((h1
->root
.u
.def
.value
4508 + h1
->root
.u
.def
.section
->output_section
->vma
4509 + h1
->root
.u
.def
.section
->output_offset
)
4511 if (pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
!= 0)
4512 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4513 iat_va
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
4518 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4519 " because .idata$6 is missing"), abfd
);
4525 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4526 (bfd_get_symbol_leading_char (abfd
) != 0
4527 ? "__tls_used" : "_tls_used"),
4528 false, false, true);
4531 if ((h1
->root
.type
== bfd_link_hash_defined
4532 || h1
->root
.type
== bfd_link_hash_defweak
)
4533 && h1
->root
.u
.def
.section
!= NULL
4534 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4535 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].VirtualAddress
=
4536 (h1
->root
.u
.def
.value
4537 + h1
->root
.u
.def
.section
->output_section
->vma
4538 + h1
->root
.u
.def
.section
->output_offset
4539 - pe_data (abfd
)->pe_opthdr
.ImageBase
);
4543 (_("%pB: unable to fill in DataDictionary[9] because __tls_used is missing"),
4547 /* According to PECOFF sepcifications by Microsoft version 8.2
4548 the TLS data directory consists of 4 pointers, followed
4549 by two 4-byte integer. This implies that the total size
4550 is different for 32-bit and 64-bit executables. */
4551 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
4552 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x18;
4554 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x28;
4558 /* If there is a .pdata section and we have linked pdata finally, we
4559 need to sort the entries ascending. */
4560 #if !defined(COFF_WITH_pep) && (defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64) || defined(COFF_WITH_peLoongArch64))
4562 asection
*sec
= bfd_get_section_by_name (abfd
, ".pdata");
4566 bfd_size_type x
= sec
->rawsize
;
4569 if (bfd_malloc_and_get_section (abfd
, sec
, &tmp_data
))
4573 12, sort_x64_pdata
);
4574 bfd_set_section_contents (pfinfo
->output_bfd
, sec
,
4584 rsrc_process_section (abfd
, pfinfo
);
4586 /* If we couldn't find idata$2, we either have an excessively
4587 trivial program or are in DEEP trouble; we have to assume trivial