1 /* Support for the generic parts of PE/PEI; the common executable parts.
2 Copyright (C) 1995-2021 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, or COFF_WITH_pex64
64 depending on whether we're compiling for straight PE or PE+. */
70 #include "coff/internal.h"
72 #include "libiberty.h"
80 /* NOTE: it's strange to be including an architecture specific header
81 in what's supposed to be general (to PE/PEI) code. However, that's
82 where the definitions are, and they don't vary per architecture
83 within PE/PEI, so we get them from there. FIXME: The lack of
84 variance is an assumption which may prove to be incorrect if new
85 PE/PEI targets are created. */
86 #if defined COFF_WITH_pex64
87 # include "coff/x86_64.h"
88 #elif defined COFF_WITH_pep
89 # include "coff/ia64.h"
91 # include "coff/i386.h"
97 #include "safe-ctype.h"
99 #if defined COFF_WITH_pep || defined COFF_WITH_pex64
101 # define AOUTSZ PEPAOUTSZ
102 # define PEAOUTHDR PEPAOUTHDR
105 #define HighBitSet(val) ((val) & 0x80000000)
106 #define SetHighBit(val) ((val) | 0x80000000)
107 #define WithoutHighBit(val) ((val) & 0x7fffffff)
110 _bfd_XXi_swap_sym_in (bfd
* abfd
, void * ext1
, void * in1
)
112 SYMENT
*ext
= (SYMENT
*) ext1
;
113 struct internal_syment
*in
= (struct internal_syment
*) in1
;
115 if (ext
->e
.e_name
[0] == 0)
117 in
->_n
._n_n
._n_zeroes
= 0;
118 in
->_n
._n_n
._n_offset
= H_GET_32 (abfd
, ext
->e
.e
.e_offset
);
121 memcpy (in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
123 in
->n_value
= H_GET_32 (abfd
, ext
->e_value
);
124 in
->n_scnum
= (short) H_GET_16 (abfd
, ext
->e_scnum
);
126 if (sizeof (ext
->e_type
) == 2)
127 in
->n_type
= H_GET_16 (abfd
, ext
->e_type
);
129 in
->n_type
= H_GET_32 (abfd
, ext
->e_type
);
131 in
->n_sclass
= H_GET_8 (abfd
, ext
->e_sclass
);
132 in
->n_numaux
= H_GET_8 (abfd
, ext
->e_numaux
);
134 #ifndef STRICT_PE_FORMAT
135 /* This is for Gnu-created DLLs. */
137 /* The section symbols for the .idata$ sections have class 0x68
138 (C_SECTION), which MS documentation indicates is a section
139 symbol. Unfortunately, the value field in the symbol is simply a
140 copy of the .idata section's flags rather than something useful.
141 When these symbols are encountered, change the value to 0 so that
142 they will be handled somewhat correctly in the bfd code. */
143 if (in
->n_sclass
== C_SECTION
)
145 char namebuf
[SYMNMLEN
+ 1];
146 const char *name
= NULL
;
150 /* Create synthetic empty sections as needed. DJ */
151 if (in
->n_scnum
== 0)
155 name
= _bfd_coff_internal_syment_name (abfd
, in
, namebuf
);
158 _bfd_error_handler (_("%pB: unable to find name for empty section"),
160 bfd_set_error (bfd_error_invalid_target
);
164 sec
= bfd_get_section_by_name (abfd
, name
);
166 in
->n_scnum
= sec
->target_index
;
169 if (in
->n_scnum
== 0)
171 int unused_section_number
= 0;
177 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
178 if (unused_section_number
<= sec
->target_index
)
179 unused_section_number
= sec
->target_index
+ 1;
181 name_len
= strlen (name
) + 1;
182 sec_name
= bfd_alloc (abfd
, name_len
);
183 if (sec_name
== NULL
)
185 _bfd_error_handler (_("%pB: out of memory creating name "
186 "for empty section"), abfd
);
189 memcpy (sec_name
, name
, name_len
);
191 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_DATA
| SEC_LOAD
;
192 sec
= bfd_make_section_anyway_with_flags (abfd
, sec_name
, flags
);
195 _bfd_error_handler (_("%pB: unable to create fake empty section"),
204 sec
->rel_filepos
= 0;
205 sec
->reloc_count
= 0;
206 sec
->line_filepos
= 0;
207 sec
->lineno_count
= 0;
208 sec
->userdata
= NULL
;
210 sec
->alignment_power
= 2;
212 sec
->target_index
= unused_section_number
;
214 in
->n_scnum
= unused_section_number
;
216 in
->n_sclass
= C_STAT
;
222 abs_finder (bfd
* abfd ATTRIBUTE_UNUSED
, asection
* sec
, void * data
)
224 bfd_vma abs_val
= * (bfd_vma
*) data
;
226 return (sec
->vma
<= abs_val
) && ((sec
->vma
+ (1ULL << 32)) > abs_val
);
230 _bfd_XXi_swap_sym_out (bfd
* abfd
, void * inp
, void * extp
)
232 struct internal_syment
*in
= (struct internal_syment
*) inp
;
233 SYMENT
*ext
= (SYMENT
*) extp
;
235 if (in
->_n
._n_name
[0] == 0)
237 H_PUT_32 (abfd
, 0, ext
->e
.e
.e_zeroes
);
238 H_PUT_32 (abfd
, in
->_n
._n_n
._n_offset
, ext
->e
.e
.e_offset
);
241 memcpy (ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
243 /* The PE32 and PE32+ formats only use 4 bytes to hold the value of a
244 symbol. This is a problem on 64-bit targets where we can generate
245 absolute symbols with values >= 1^32. We try to work around this
246 problem by finding a section whose base address is sufficient to
247 reduce the absolute value to < 1^32, and then transforming the
248 symbol into a section relative symbol. This of course is a hack. */
249 if (sizeof (in
->n_value
) > 4
250 /* The strange computation of the shift amount is here in order to
251 avoid a compile time warning about the comparison always being
252 false. It does not matter if this test fails to work as expected
253 as the worst that can happen is that some absolute symbols are
254 needlessly converted into section relative symbols. */
255 && in
->n_value
> ((1ULL << (sizeof (in
->n_value
) > 4 ? 32 : 31)) - 1)
256 && in
->n_scnum
== N_ABS
)
260 sec
= bfd_sections_find_if (abfd
, abs_finder
, & in
->n_value
);
263 in
->n_value
-= sec
->vma
;
264 in
->n_scnum
= sec
->target_index
;
266 /* else: FIXME: The value is outside the range of any section. This
267 happens for __image_base__ and __ImageBase and maybe some other
268 symbols as well. We should find a way to handle these values. */
271 H_PUT_32 (abfd
, in
->n_value
, ext
->e_value
);
272 H_PUT_16 (abfd
, in
->n_scnum
, ext
->e_scnum
);
274 if (sizeof (ext
->e_type
) == 2)
275 H_PUT_16 (abfd
, in
->n_type
, ext
->e_type
);
277 H_PUT_32 (abfd
, in
->n_type
, ext
->e_type
);
279 H_PUT_8 (abfd
, in
->n_sclass
, ext
->e_sclass
);
280 H_PUT_8 (abfd
, in
->n_numaux
, ext
->e_numaux
);
286 _bfd_XXi_swap_aux_in (bfd
* abfd
,
290 int indx ATTRIBUTE_UNUSED
,
291 int numaux ATTRIBUTE_UNUSED
,
294 AUXENT
*ext
= (AUXENT
*) ext1
;
295 union internal_auxent
*in
= (union internal_auxent
*) in1
;
297 /* PR 17521: Make sure that all fields in the aux structure
299 memset (in
, 0, sizeof * in
);
303 if (ext
->x_file
.x_fname
[0] == 0)
305 in
->x_file
.x_n
.x_zeroes
= 0;
306 in
->x_file
.x_n
.x_offset
= H_GET_32 (abfd
, ext
->x_file
.x_n
.x_offset
);
309 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
317 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN (abfd
, ext
);
318 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC (abfd
, ext
);
319 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO (abfd
, ext
);
320 in
->x_scn
.x_checksum
= H_GET_32 (abfd
, ext
->x_scn
.x_checksum
);
321 in
->x_scn
.x_associated
= H_GET_16 (abfd
, ext
->x_scn
.x_associated
);
322 in
->x_scn
.x_comdat
= H_GET_8 (abfd
, ext
->x_scn
.x_comdat
);
328 in
->x_sym
.x_tagndx
.l
= H_GET_32 (abfd
, ext
->x_sym
.x_tagndx
);
329 in
->x_sym
.x_tvndx
= H_GET_16 (abfd
, ext
->x_sym
.x_tvndx
);
331 if (in_class
== C_BLOCK
|| in_class
== C_FCN
|| ISFCN (type
)
334 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR (abfd
, ext
);
335 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX (abfd
, ext
);
339 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0] =
340 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
341 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1] =
342 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
343 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2] =
344 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
345 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3] =
346 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
351 in
->x_sym
.x_misc
.x_fsize
= H_GET_32 (abfd
, ext
->x_sym
.x_misc
.x_fsize
);
355 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO (abfd
, ext
);
356 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE (abfd
, ext
);
361 _bfd_XXi_swap_aux_out (bfd
* abfd
,
365 int indx ATTRIBUTE_UNUSED
,
366 int numaux ATTRIBUTE_UNUSED
,
369 union internal_auxent
*in
= (union internal_auxent
*) inp
;
370 AUXENT
*ext
= (AUXENT
*) extp
;
372 memset (ext
, 0, AUXESZ
);
377 if (in
->x_file
.x_fname
[0] == 0)
379 H_PUT_32 (abfd
, 0, ext
->x_file
.x_n
.x_zeroes
);
380 H_PUT_32 (abfd
, in
->x_file
.x_n
.x_offset
, ext
->x_file
.x_n
.x_offset
);
383 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, sizeof (ext
->x_file
.x_fname
));
392 PUT_SCN_SCNLEN (abfd
, in
->x_scn
.x_scnlen
, ext
);
393 PUT_SCN_NRELOC (abfd
, in
->x_scn
.x_nreloc
, ext
);
394 PUT_SCN_NLINNO (abfd
, in
->x_scn
.x_nlinno
, ext
);
395 H_PUT_32 (abfd
, in
->x_scn
.x_checksum
, ext
->x_scn
.x_checksum
);
396 H_PUT_16 (abfd
, in
->x_scn
.x_associated
, ext
->x_scn
.x_associated
);
397 H_PUT_8 (abfd
, in
->x_scn
.x_comdat
, ext
->x_scn
.x_comdat
);
403 H_PUT_32 (abfd
, in
->x_sym
.x_tagndx
.l
, ext
->x_sym
.x_tagndx
);
404 H_PUT_16 (abfd
, in
->x_sym
.x_tvndx
, ext
->x_sym
.x_tvndx
);
406 if (in_class
== C_BLOCK
|| in_class
== C_FCN
|| ISFCN (type
)
409 PUT_FCN_LNNOPTR (abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
410 PUT_FCN_ENDNDX (abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
414 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0],
415 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
416 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1],
417 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
418 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2],
419 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
420 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3],
421 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
425 H_PUT_32 (abfd
, in
->x_sym
.x_misc
.x_fsize
, ext
->x_sym
.x_misc
.x_fsize
);
428 PUT_LNSZ_LNNO (abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
429 PUT_LNSZ_SIZE (abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
436 _bfd_XXi_swap_lineno_in (bfd
* abfd
, void * ext1
, void * in1
)
438 LINENO
*ext
= (LINENO
*) ext1
;
439 struct internal_lineno
*in
= (struct internal_lineno
*) in1
;
441 in
->l_addr
.l_symndx
= H_GET_32 (abfd
, ext
->l_addr
.l_symndx
);
442 in
->l_lnno
= GET_LINENO_LNNO (abfd
, ext
);
446 _bfd_XXi_swap_lineno_out (bfd
* abfd
, void * inp
, void * outp
)
448 struct internal_lineno
*in
= (struct internal_lineno
*) inp
;
449 struct external_lineno
*ext
= (struct external_lineno
*) outp
;
450 H_PUT_32 (abfd
, in
->l_addr
.l_symndx
, ext
->l_addr
.l_symndx
);
452 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
457 _bfd_XXi_swap_aouthdr_in (bfd
* abfd
,
461 PEAOUTHDR
* src
= (PEAOUTHDR
*) aouthdr_ext1
;
462 AOUTHDR
* aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
463 struct internal_aouthdr
*aouthdr_int
464 = (struct internal_aouthdr
*) aouthdr_int1
;
465 struct internal_extra_pe_aouthdr
*a
= &aouthdr_int
->pe
;
467 aouthdr_int
->magic
= H_GET_16 (abfd
, aouthdr_ext
->magic
);
468 aouthdr_int
->vstamp
= H_GET_16 (abfd
, aouthdr_ext
->vstamp
);
469 aouthdr_int
->tsize
= GET_AOUTHDR_TSIZE (abfd
, aouthdr_ext
->tsize
);
470 aouthdr_int
->dsize
= GET_AOUTHDR_DSIZE (abfd
, aouthdr_ext
->dsize
);
471 aouthdr_int
->bsize
= GET_AOUTHDR_BSIZE (abfd
, aouthdr_ext
->bsize
);
472 aouthdr_int
->entry
= GET_AOUTHDR_ENTRY (abfd
, aouthdr_ext
->entry
);
473 aouthdr_int
->text_start
=
474 GET_AOUTHDR_TEXT_START (abfd
, aouthdr_ext
->text_start
);
476 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
477 /* PE32+ does not have data_start member! */
478 aouthdr_int
->data_start
=
479 GET_AOUTHDR_DATA_START (abfd
, aouthdr_ext
->data_start
);
480 a
->BaseOfData
= aouthdr_int
->data_start
;
483 a
->Magic
= aouthdr_int
->magic
;
484 a
->MajorLinkerVersion
= H_GET_8 (abfd
, aouthdr_ext
->vstamp
);
485 a
->MinorLinkerVersion
= H_GET_8 (abfd
, aouthdr_ext
->vstamp
+ 1);
486 a
->SizeOfCode
= aouthdr_int
->tsize
;
487 a
->SizeOfInitializedData
= aouthdr_int
->dsize
;
488 a
->SizeOfUninitializedData
= aouthdr_int
->bsize
;
489 a
->AddressOfEntryPoint
= aouthdr_int
->entry
;
490 a
->BaseOfCode
= aouthdr_int
->text_start
;
491 a
->ImageBase
= GET_OPTHDR_IMAGE_BASE (abfd
, src
->ImageBase
);
492 a
->SectionAlignment
= H_GET_32 (abfd
, src
->SectionAlignment
);
493 a
->FileAlignment
= H_GET_32 (abfd
, src
->FileAlignment
);
494 a
->MajorOperatingSystemVersion
=
495 H_GET_16 (abfd
, src
->MajorOperatingSystemVersion
);
496 a
->MinorOperatingSystemVersion
=
497 H_GET_16 (abfd
, src
->MinorOperatingSystemVersion
);
498 a
->MajorImageVersion
= H_GET_16 (abfd
, src
->MajorImageVersion
);
499 a
->MinorImageVersion
= H_GET_16 (abfd
, src
->MinorImageVersion
);
500 a
->MajorSubsystemVersion
= H_GET_16 (abfd
, src
->MajorSubsystemVersion
);
501 a
->MinorSubsystemVersion
= H_GET_16 (abfd
, src
->MinorSubsystemVersion
);
502 a
->Reserved1
= H_GET_32 (abfd
, src
->Reserved1
);
503 a
->SizeOfImage
= H_GET_32 (abfd
, src
->SizeOfImage
);
504 a
->SizeOfHeaders
= H_GET_32 (abfd
, src
->SizeOfHeaders
);
505 a
->CheckSum
= H_GET_32 (abfd
, src
->CheckSum
);
506 a
->Subsystem
= H_GET_16 (abfd
, src
->Subsystem
);
507 a
->DllCharacteristics
= H_GET_16 (abfd
, src
->DllCharacteristics
);
508 a
->SizeOfStackReserve
=
509 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd
, src
->SizeOfStackReserve
);
510 a
->SizeOfStackCommit
=
511 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd
, src
->SizeOfStackCommit
);
512 a
->SizeOfHeapReserve
=
513 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd
, src
->SizeOfHeapReserve
);
514 a
->SizeOfHeapCommit
=
515 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd
, src
->SizeOfHeapCommit
);
516 a
->LoaderFlags
= H_GET_32 (abfd
, src
->LoaderFlags
);
517 a
->NumberOfRvaAndSizes
= H_GET_32 (abfd
, src
->NumberOfRvaAndSizes
);
522 /* PR 17512: Corrupt PE binaries can cause seg-faults. */
523 if (a
->NumberOfRvaAndSizes
> IMAGE_NUMBEROF_DIRECTORY_ENTRIES
)
525 /* xgettext:c-format */
527 (_("%pB: aout header specifies an invalid number of"
528 " data-directory entries: %u"), abfd
, a
->NumberOfRvaAndSizes
);
529 bfd_set_error (bfd_error_bad_value
);
531 /* Paranoia: If the number is corrupt, then assume that the
532 actual entries themselves might be corrupt as well. */
533 a
->NumberOfRvaAndSizes
= 0;
536 for (idx
= 0; idx
< a
->NumberOfRvaAndSizes
; idx
++)
538 /* If data directory is empty, rva also should be 0. */
540 H_GET_32 (abfd
, src
->DataDirectory
[idx
][1]);
542 a
->DataDirectory
[idx
].Size
= size
;
545 a
->DataDirectory
[idx
].VirtualAddress
=
546 H_GET_32 (abfd
, src
->DataDirectory
[idx
][0]);
548 a
->DataDirectory
[idx
].VirtualAddress
= 0;
551 while (idx
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
)
553 a
->DataDirectory
[idx
].Size
= 0;
554 a
->DataDirectory
[idx
].VirtualAddress
= 0;
559 if (aouthdr_int
->entry
)
561 aouthdr_int
->entry
+= a
->ImageBase
;
562 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
563 aouthdr_int
->entry
&= 0xffffffff;
567 if (aouthdr_int
->tsize
)
569 aouthdr_int
->text_start
+= a
->ImageBase
;
570 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
571 aouthdr_int
->text_start
&= 0xffffffff;
575 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
576 /* PE32+ does not have data_start member! */
577 if (aouthdr_int
->dsize
)
579 aouthdr_int
->data_start
+= a
->ImageBase
;
580 aouthdr_int
->data_start
&= 0xffffffff;
585 /* A support function for below. */
588 add_data_entry (bfd
* abfd
,
589 struct internal_extra_pe_aouthdr
*aout
,
594 asection
*sec
= bfd_get_section_by_name (abfd
, name
);
596 /* Add import directory information if it exists. */
598 && (coff_section_data (abfd
, sec
) != NULL
)
599 && (pei_section_data (abfd
, sec
) != NULL
))
601 /* If data directory is empty, rva also should be 0. */
602 int size
= pei_section_data (abfd
, sec
)->virt_size
;
603 aout
->DataDirectory
[idx
].Size
= size
;
607 aout
->DataDirectory
[idx
].VirtualAddress
=
608 (sec
->vma
- base
) & 0xffffffff;
609 sec
->flags
|= SEC_DATA
;
615 _bfd_XXi_swap_aouthdr_out (bfd
* abfd
, void * in
, void * out
)
617 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*) in
;
618 pe_data_type
*pe
= pe_data (abfd
);
619 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
620 PEAOUTHDR
*aouthdr_out
= (PEAOUTHDR
*) out
;
622 IMAGE_DATA_DIRECTORY idata2
, idata5
, tls
;
624 sa
= extra
->SectionAlignment
;
625 fa
= extra
->FileAlignment
;
626 ib
= extra
->ImageBase
;
628 idata2
= pe
->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
];
629 idata5
= pe
->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
];
630 tls
= pe
->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
];
632 if (aouthdr_in
->tsize
)
634 aouthdr_in
->text_start
-= ib
;
635 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
636 aouthdr_in
->text_start
&= 0xffffffff;
640 if (aouthdr_in
->dsize
)
642 aouthdr_in
->data_start
-= ib
;
643 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
644 aouthdr_in
->data_start
&= 0xffffffff;
648 if (aouthdr_in
->entry
)
650 aouthdr_in
->entry
-= ib
;
651 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
652 aouthdr_in
->entry
&= 0xffffffff;
656 #define FA(x) (((x) + fa -1 ) & (- fa))
657 #define SA(x) (((x) + sa -1 ) & (- sa))
659 /* We like to have the sizes aligned. */
660 aouthdr_in
->bsize
= FA (aouthdr_in
->bsize
);
662 extra
->NumberOfRvaAndSizes
= IMAGE_NUMBEROF_DIRECTORY_ENTRIES
;
664 add_data_entry (abfd
, extra
, PE_EXPORT_TABLE
, ".edata", ib
);
665 add_data_entry (abfd
, extra
, PE_RESOURCE_TABLE
, ".rsrc", ib
);
666 add_data_entry (abfd
, extra
, PE_EXCEPTION_TABLE
, ".pdata", ib
);
668 /* In theory we do not need to call add_data_entry for .idata$2 or
669 .idata$5. It will be done in bfd_coff_final_link where all the
670 required information is available. If however, we are not going
671 to perform a final link, eg because we have been invoked by objcopy
672 or strip, then we need to make sure that these Data Directory
673 entries are initialised properly.
675 So - we copy the input values into the output values, and then, if
676 a final link is going to be performed, it can overwrite them. */
677 extra
->DataDirectory
[PE_IMPORT_TABLE
] = idata2
;
678 extra
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
] = idata5
;
679 extra
->DataDirectory
[PE_TLS_TABLE
] = tls
;
681 if (extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
== 0)
682 /* Until other .idata fixes are made (pending patch), the entry for
683 .idata is needed for backwards compatibility. FIXME. */
684 add_data_entry (abfd
, extra
, PE_IMPORT_TABLE
, ".idata", ib
);
686 /* For some reason, the virtual size (which is what's set by
687 add_data_entry) for .reloc is not the same as the size recorded
688 in this slot by MSVC; it doesn't seem to cause problems (so far),
689 but since it's the best we've got, use it. It does do the right
691 if (pe
->has_reloc_section
)
692 add_data_entry (abfd
, extra
, PE_BASE_RELOCATION_TABLE
, ".reloc", ib
);
701 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
703 int rounded
= FA (sec
->size
);
708 /* The first non-zero section filepos is the header size.
709 Sections without contents will have a filepos of 0. */
711 hsize
= sec
->filepos
;
712 if (sec
->flags
& SEC_DATA
)
714 if (sec
->flags
& SEC_CODE
)
716 /* The image size is the total VIRTUAL size (which is what is
717 in the virt_size field). Files have been seen (from MSVC
718 5.0 link.exe) where the file size of the .data segment is
719 quite small compared to the virtual size. Without this
720 fix, strip munges the file.
722 FIXME: We need to handle holes between sections, which may
723 happpen when we covert from another format. We just use
724 the virtual address and virtual size of the last section
725 for the image size. */
726 if (coff_section_data (abfd
, sec
) != NULL
727 && pei_section_data (abfd
, sec
) != NULL
)
728 isize
= (sec
->vma
- extra
->ImageBase
729 + SA (FA (pei_section_data (abfd
, sec
)->virt_size
)));
732 aouthdr_in
->dsize
= dsize
;
733 aouthdr_in
->tsize
= tsize
;
734 extra
->SizeOfHeaders
= hsize
;
735 extra
->SizeOfImage
= isize
;
738 H_PUT_16 (abfd
, aouthdr_in
->magic
, aouthdr_out
->standard
.magic
);
740 /* e.g. 219510000 is linker version 2.19 */
741 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
743 /* This piece of magic sets the "linker version" field to
745 H_PUT_16 (abfd
, (LINKER_VERSION
/ 100 + (LINKER_VERSION
% 100) * 256),
746 aouthdr_out
->standard
.vstamp
);
748 PUT_AOUTHDR_TSIZE (abfd
, aouthdr_in
->tsize
, aouthdr_out
->standard
.tsize
);
749 PUT_AOUTHDR_DSIZE (abfd
, aouthdr_in
->dsize
, aouthdr_out
->standard
.dsize
);
750 PUT_AOUTHDR_BSIZE (abfd
, aouthdr_in
->bsize
, aouthdr_out
->standard
.bsize
);
751 PUT_AOUTHDR_ENTRY (abfd
, aouthdr_in
->entry
, aouthdr_out
->standard
.entry
);
752 PUT_AOUTHDR_TEXT_START (abfd
, aouthdr_in
->text_start
,
753 aouthdr_out
->standard
.text_start
);
755 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
756 /* PE32+ does not have data_start member! */
757 PUT_AOUTHDR_DATA_START (abfd
, aouthdr_in
->data_start
,
758 aouthdr_out
->standard
.data_start
);
761 PUT_OPTHDR_IMAGE_BASE (abfd
, extra
->ImageBase
, aouthdr_out
->ImageBase
);
762 H_PUT_32 (abfd
, extra
->SectionAlignment
, aouthdr_out
->SectionAlignment
);
763 H_PUT_32 (abfd
, extra
->FileAlignment
, aouthdr_out
->FileAlignment
);
764 H_PUT_16 (abfd
, extra
->MajorOperatingSystemVersion
,
765 aouthdr_out
->MajorOperatingSystemVersion
);
766 H_PUT_16 (abfd
, extra
->MinorOperatingSystemVersion
,
767 aouthdr_out
->MinorOperatingSystemVersion
);
768 H_PUT_16 (abfd
, extra
->MajorImageVersion
, aouthdr_out
->MajorImageVersion
);
769 H_PUT_16 (abfd
, extra
->MinorImageVersion
, aouthdr_out
->MinorImageVersion
);
770 H_PUT_16 (abfd
, extra
->MajorSubsystemVersion
,
771 aouthdr_out
->MajorSubsystemVersion
);
772 H_PUT_16 (abfd
, extra
->MinorSubsystemVersion
,
773 aouthdr_out
->MinorSubsystemVersion
);
774 H_PUT_32 (abfd
, extra
->Reserved1
, aouthdr_out
->Reserved1
);
775 H_PUT_32 (abfd
, extra
->SizeOfImage
, aouthdr_out
->SizeOfImage
);
776 H_PUT_32 (abfd
, extra
->SizeOfHeaders
, aouthdr_out
->SizeOfHeaders
);
777 H_PUT_32 (abfd
, extra
->CheckSum
, aouthdr_out
->CheckSum
);
778 H_PUT_16 (abfd
, extra
->Subsystem
, aouthdr_out
->Subsystem
);
779 H_PUT_16 (abfd
, extra
->DllCharacteristics
, aouthdr_out
->DllCharacteristics
);
780 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd
, extra
->SizeOfStackReserve
,
781 aouthdr_out
->SizeOfStackReserve
);
782 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd
, extra
->SizeOfStackCommit
,
783 aouthdr_out
->SizeOfStackCommit
);
784 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd
, extra
->SizeOfHeapReserve
,
785 aouthdr_out
->SizeOfHeapReserve
);
786 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd
, extra
->SizeOfHeapCommit
,
787 aouthdr_out
->SizeOfHeapCommit
);
788 H_PUT_32 (abfd
, extra
->LoaderFlags
, aouthdr_out
->LoaderFlags
);
789 H_PUT_32 (abfd
, extra
->NumberOfRvaAndSizes
,
790 aouthdr_out
->NumberOfRvaAndSizes
);
794 for (idx
= 0; idx
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; idx
++)
796 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].VirtualAddress
,
797 aouthdr_out
->DataDirectory
[idx
][0]);
798 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].Size
,
799 aouthdr_out
->DataDirectory
[idx
][1]);
807 _bfd_XXi_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
810 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
811 struct external_PEI_filehdr
*filehdr_out
= (struct external_PEI_filehdr
*) out
;
813 if (pe_data (abfd
)->has_reloc_section
814 || pe_data (abfd
)->dont_strip_reloc
)
815 filehdr_in
->f_flags
&= ~F_RELFLG
;
817 if (pe_data (abfd
)->dll
)
818 filehdr_in
->f_flags
|= F_DLL
;
820 filehdr_in
->pe
.e_magic
= IMAGE_DOS_SIGNATURE
;
821 filehdr_in
->pe
.e_cblp
= 0x90;
822 filehdr_in
->pe
.e_cp
= 0x3;
823 filehdr_in
->pe
.e_crlc
= 0x0;
824 filehdr_in
->pe
.e_cparhdr
= 0x4;
825 filehdr_in
->pe
.e_minalloc
= 0x0;
826 filehdr_in
->pe
.e_maxalloc
= 0xffff;
827 filehdr_in
->pe
.e_ss
= 0x0;
828 filehdr_in
->pe
.e_sp
= 0xb8;
829 filehdr_in
->pe
.e_csum
= 0x0;
830 filehdr_in
->pe
.e_ip
= 0x0;
831 filehdr_in
->pe
.e_cs
= 0x0;
832 filehdr_in
->pe
.e_lfarlc
= 0x40;
833 filehdr_in
->pe
.e_ovno
= 0x0;
835 for (idx
= 0; idx
< 4; idx
++)
836 filehdr_in
->pe
.e_res
[idx
] = 0x0;
838 filehdr_in
->pe
.e_oemid
= 0x0;
839 filehdr_in
->pe
.e_oeminfo
= 0x0;
841 for (idx
= 0; idx
< 10; idx
++)
842 filehdr_in
->pe
.e_res2
[idx
] = 0x0;
844 filehdr_in
->pe
.e_lfanew
= 0x80;
846 /* This next collection of data are mostly just characters. It
847 appears to be constant within the headers put on NT exes. */
848 memcpy (filehdr_in
->pe
.dos_message
, pe_data (abfd
)->dos_message
,
849 sizeof (filehdr_in
->pe
.dos_message
));
851 filehdr_in
->pe
.nt_signature
= IMAGE_NT_SIGNATURE
;
853 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
854 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
856 /* Use a real timestamp by default, unless the no-insert-timestamp
857 option was chosen. */
858 if ((pe_data (abfd
)->timestamp
) == -1)
859 H_PUT_32 (abfd
, time (0), filehdr_out
->f_timdat
);
861 H_PUT_32 (abfd
, pe_data (abfd
)->timestamp
, filehdr_out
->f_timdat
);
863 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
864 filehdr_out
->f_symptr
);
865 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
866 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
867 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
869 /* Put in extra dos header stuff. This data remains essentially
870 constant, it just has to be tacked on to the beginning of all exes
872 H_PUT_16 (abfd
, filehdr_in
->pe
.e_magic
, filehdr_out
->e_magic
);
873 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cblp
, filehdr_out
->e_cblp
);
874 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cp
, filehdr_out
->e_cp
);
875 H_PUT_16 (abfd
, filehdr_in
->pe
.e_crlc
, filehdr_out
->e_crlc
);
876 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cparhdr
, filehdr_out
->e_cparhdr
);
877 H_PUT_16 (abfd
, filehdr_in
->pe
.e_minalloc
, filehdr_out
->e_minalloc
);
878 H_PUT_16 (abfd
, filehdr_in
->pe
.e_maxalloc
, filehdr_out
->e_maxalloc
);
879 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ss
, filehdr_out
->e_ss
);
880 H_PUT_16 (abfd
, filehdr_in
->pe
.e_sp
, filehdr_out
->e_sp
);
881 H_PUT_16 (abfd
, filehdr_in
->pe
.e_csum
, filehdr_out
->e_csum
);
882 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ip
, filehdr_out
->e_ip
);
883 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cs
, filehdr_out
->e_cs
);
884 H_PUT_16 (abfd
, filehdr_in
->pe
.e_lfarlc
, filehdr_out
->e_lfarlc
);
885 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ovno
, filehdr_out
->e_ovno
);
887 for (idx
= 0; idx
< 4; idx
++)
888 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res
[idx
], filehdr_out
->e_res
[idx
]);
890 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oemid
, filehdr_out
->e_oemid
);
891 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oeminfo
, filehdr_out
->e_oeminfo
);
893 for (idx
= 0; idx
< 10; idx
++)
894 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res2
[idx
], filehdr_out
->e_res2
[idx
]);
896 H_PUT_32 (abfd
, filehdr_in
->pe
.e_lfanew
, filehdr_out
->e_lfanew
);
898 for (idx
= 0; idx
< 16; idx
++)
899 H_PUT_32 (abfd
, filehdr_in
->pe
.dos_message
[idx
],
900 filehdr_out
->dos_message
[idx
]);
902 /* Also put in the NT signature. */
903 H_PUT_32 (abfd
, filehdr_in
->pe
.nt_signature
, filehdr_out
->nt_signature
);
909 _bfd_XX_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
911 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
912 FILHDR
*filehdr_out
= (FILHDR
*) out
;
914 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
915 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
916 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->f_timdat
);
917 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
, filehdr_out
->f_symptr
);
918 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
919 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
920 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
926 _bfd_XXi_swap_scnhdr_out (bfd
* abfd
, void * in
, void * out
)
928 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*) in
;
929 SCNHDR
*scnhdr_ext
= (SCNHDR
*) out
;
930 unsigned int ret
= SCNHSZ
;
934 memcpy (scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof (scnhdr_int
->s_name
));
936 ss
= scnhdr_int
->s_vaddr
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
937 if (scnhdr_int
->s_vaddr
< pe_data (abfd
)->pe_opthdr
.ImageBase
)
938 _bfd_error_handler (_("%pB:%.8s: section below image base"),
939 abfd
, scnhdr_int
->s_name
);
940 else if(ss
!= (ss
& 0xffffffff))
941 _bfd_error_handler (_("%pB:%.8s: RVA truncated"), abfd
, scnhdr_int
->s_name
);
942 PUT_SCNHDR_VADDR (abfd
, ss
& 0xffffffff, scnhdr_ext
->s_vaddr
);
944 /* NT wants the size data to be rounded up to the next
945 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
947 if ((scnhdr_int
->s_flags
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
) != 0)
949 if (bfd_pei_p (abfd
))
951 ps
= scnhdr_int
->s_size
;
957 ss
= scnhdr_int
->s_size
;
962 if (bfd_pei_p (abfd
))
963 ps
= scnhdr_int
->s_paddr
;
967 ss
= scnhdr_int
->s_size
;
970 PUT_SCNHDR_SIZE (abfd
, ss
,
973 /* s_paddr in PE is really the virtual size. */
974 PUT_SCNHDR_PADDR (abfd
, ps
, scnhdr_ext
->s_paddr
);
976 PUT_SCNHDR_SCNPTR (abfd
, scnhdr_int
->s_scnptr
,
977 scnhdr_ext
->s_scnptr
);
978 PUT_SCNHDR_RELPTR (abfd
, scnhdr_int
->s_relptr
,
979 scnhdr_ext
->s_relptr
);
980 PUT_SCNHDR_LNNOPTR (abfd
, scnhdr_int
->s_lnnoptr
,
981 scnhdr_ext
->s_lnnoptr
);
984 /* Extra flags must be set when dealing with PE. All sections should also
985 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
986 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
987 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
988 (this is especially important when dealing with the .idata section since
989 the addresses for routines from .dlls must be overwritten). If .reloc
990 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
991 (0x02000000). Also, the resource data should also be read and
994 /* FIXME: Alignment is also encoded in this field, at least on
995 ARM-WINCE. Although - how do we get the original alignment field
1000 char section_name
[SCNNMLEN
];
1001 unsigned long must_have
;
1003 pe_required_section_flags
;
1005 pe_required_section_flags known_sections
[] =
1007 { ".arch", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
| IMAGE_SCN_ALIGN_8BYTES
},
1008 { ".bss", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1009 { ".data", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1010 { ".edata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1011 { ".idata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1012 { ".pdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1013 { ".rdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1014 { ".reloc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
},
1015 { ".rsrc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1016 { ".text" , IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_CODE
| IMAGE_SCN_MEM_EXECUTE
},
1017 { ".tls", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1018 { ".xdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1021 pe_required_section_flags
* p
;
1023 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1024 we know exactly what this specific section wants so we remove it
1025 and then allow the must_have field to add it back in if necessary.
1026 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1027 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
1028 by ld --enable-auto-import (if auto-import is actually needed),
1029 by ld --omagic, or by obcopy --writable-text. */
1031 for (p
= known_sections
;
1032 p
< known_sections
+ ARRAY_SIZE (known_sections
);
1034 if (memcmp (scnhdr_int
->s_name
, p
->section_name
, SCNNMLEN
) == 0)
1036 if (memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text")
1037 || (bfd_get_file_flags (abfd
) & WP_TEXT
))
1038 scnhdr_int
->s_flags
&= ~IMAGE_SCN_MEM_WRITE
;
1039 scnhdr_int
->s_flags
|= p
->must_have
;
1043 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1046 if (coff_data (abfd
)->link_info
1047 && ! bfd_link_relocatable (coff_data (abfd
)->link_info
)
1048 && ! bfd_link_pic (coff_data (abfd
)->link_info
)
1049 && memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text") == 0)
1051 /* By inference from looking at MS output, the 32 bit field
1052 which is the combination of the number_of_relocs and
1053 number_of_linenos is used for the line number count in
1054 executables. A 16-bit field won't do for cc1. The MS
1055 document says that the number of relocs is zero for
1056 executables, but the 17-th bit has been observed to be there.
1057 Overflow is not an issue: a 4G-line program will overflow a
1058 bunch of other fields long before this! */
1059 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
& 0xffff), scnhdr_ext
->s_nlnno
);
1060 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
>> 16), scnhdr_ext
->s_nreloc
);
1064 if (scnhdr_int
->s_nlnno
<= 0xffff)
1065 H_PUT_16 (abfd
, scnhdr_int
->s_nlnno
, scnhdr_ext
->s_nlnno
);
1068 /* xgettext:c-format */
1069 _bfd_error_handler (_("%pB: line number overflow: 0x%lx > 0xffff"),
1070 abfd
, scnhdr_int
->s_nlnno
);
1071 bfd_set_error (bfd_error_file_truncated
);
1072 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nlnno
);
1076 /* Although we could encode 0xffff relocs here, we do not, to be
1077 consistent with other parts of bfd. Also it lets us warn, as
1078 we should never see 0xffff here w/o having the overflow flag
1080 if (scnhdr_int
->s_nreloc
< 0xffff)
1081 H_PUT_16 (abfd
, scnhdr_int
->s_nreloc
, scnhdr_ext
->s_nreloc
);
1084 /* PE can deal with large #s of relocs, but not here. */
1085 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nreloc
);
1086 scnhdr_int
->s_flags
|= IMAGE_SCN_LNK_NRELOC_OVFL
;
1087 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1094 _bfd_XXi_swap_debugdir_in (bfd
* abfd
, void * ext1
, void * in1
)
1096 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) ext1
;
1097 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) in1
;
1099 in
->Characteristics
= H_GET_32(abfd
, ext
->Characteristics
);
1100 in
->TimeDateStamp
= H_GET_32(abfd
, ext
->TimeDateStamp
);
1101 in
->MajorVersion
= H_GET_16(abfd
, ext
->MajorVersion
);
1102 in
->MinorVersion
= H_GET_16(abfd
, ext
->MinorVersion
);
1103 in
->Type
= H_GET_32(abfd
, ext
->Type
);
1104 in
->SizeOfData
= H_GET_32(abfd
, ext
->SizeOfData
);
1105 in
->AddressOfRawData
= H_GET_32(abfd
, ext
->AddressOfRawData
);
1106 in
->PointerToRawData
= H_GET_32(abfd
, ext
->PointerToRawData
);
1110 _bfd_XXi_swap_debugdir_out (bfd
* abfd
, void * inp
, void * extp
)
1112 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) extp
;
1113 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) inp
;
1115 H_PUT_32(abfd
, in
->Characteristics
, ext
->Characteristics
);
1116 H_PUT_32(abfd
, in
->TimeDateStamp
, ext
->TimeDateStamp
);
1117 H_PUT_16(abfd
, in
->MajorVersion
, ext
->MajorVersion
);
1118 H_PUT_16(abfd
, in
->MinorVersion
, ext
->MinorVersion
);
1119 H_PUT_32(abfd
, in
->Type
, ext
->Type
);
1120 H_PUT_32(abfd
, in
->SizeOfData
, ext
->SizeOfData
);
1121 H_PUT_32(abfd
, in
->AddressOfRawData
, ext
->AddressOfRawData
);
1122 H_PUT_32(abfd
, in
->PointerToRawData
, ext
->PointerToRawData
);
1124 return sizeof (struct external_IMAGE_DEBUG_DIRECTORY
);
1128 _bfd_XXi_slurp_codeview_record (bfd
* abfd
, file_ptr where
, unsigned long length
, CODEVIEW_INFO
*cvinfo
)
1131 bfd_size_type nread
;
1133 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1136 if (length
<= sizeof (CV_INFO_PDB70
) && length
<= sizeof (CV_INFO_PDB20
))
1140 nread
= bfd_bread (buffer
, length
, abfd
);
1141 if (length
!= nread
)
1144 /* Ensure null termination of filename. */
1145 memset (buffer
+ nread
, 0, sizeof (buffer
) - nread
);
1147 cvinfo
->CVSignature
= H_GET_32 (abfd
, buffer
);
1150 if ((cvinfo
->CVSignature
== CVINFO_PDB70_CVSIGNATURE
)
1151 && (length
> sizeof (CV_INFO_PDB70
)))
1153 CV_INFO_PDB70
*cvinfo70
= (CV_INFO_PDB70
*)(buffer
);
1155 cvinfo
->Age
= H_GET_32(abfd
, cvinfo70
->Age
);
1157 /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1158 by 8 single bytes. Byte swap them so we can conveniently treat the GUID
1159 as 16 bytes in big-endian order. */
1160 bfd_putb32 (bfd_getl32 (cvinfo70
->Signature
), cvinfo
->Signature
);
1161 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[4])), &(cvinfo
->Signature
[4]));
1162 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[6])), &(cvinfo
->Signature
[6]));
1163 memcpy (&(cvinfo
->Signature
[8]), &(cvinfo70
->Signature
[8]), 8);
1165 cvinfo
->SignatureLength
= CV_INFO_SIGNATURE_LENGTH
;
1166 /* cvinfo->PdbFileName = cvinfo70->PdbFileName; */
1170 else if ((cvinfo
->CVSignature
== CVINFO_PDB20_CVSIGNATURE
)
1171 && (length
> sizeof (CV_INFO_PDB20
)))
1173 CV_INFO_PDB20
*cvinfo20
= (CV_INFO_PDB20
*)(buffer
);
1174 cvinfo
->Age
= H_GET_32(abfd
, cvinfo20
->Age
);
1175 memcpy (cvinfo
->Signature
, cvinfo20
->Signature
, 4);
1176 cvinfo
->SignatureLength
= 4;
1177 /* cvinfo->PdbFileName = cvinfo20->PdbFileName; */
1186 _bfd_XXi_write_codeview_record (bfd
* abfd
, file_ptr where
, CODEVIEW_INFO
*cvinfo
)
1188 const bfd_size_type size
= sizeof (CV_INFO_PDB70
) + 1;
1189 bfd_size_type written
;
1190 CV_INFO_PDB70
*cvinfo70
;
1193 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1196 buffer
= bfd_malloc (size
);
1200 cvinfo70
= (CV_INFO_PDB70
*) buffer
;
1201 H_PUT_32 (abfd
, CVINFO_PDB70_CVSIGNATURE
, cvinfo70
->CvSignature
);
1203 /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1204 in little-endian order, followed by 8 single bytes. */
1205 bfd_putl32 (bfd_getb32 (cvinfo
->Signature
), cvinfo70
->Signature
);
1206 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[4])), &(cvinfo70
->Signature
[4]));
1207 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[6])), &(cvinfo70
->Signature
[6]));
1208 memcpy (&(cvinfo70
->Signature
[8]), &(cvinfo
->Signature
[8]), 8);
1210 H_PUT_32 (abfd
, cvinfo
->Age
, cvinfo70
->Age
);
1211 cvinfo70
->PdbFileName
[0] = '\0';
1213 written
= bfd_bwrite (buffer
, size
, abfd
);
1217 return written
== size
? size
: 0;
1220 static char * dir_names
[IMAGE_NUMBEROF_DIRECTORY_ENTRIES
] =
1222 N_("Export Directory [.edata (or where ever we found it)]"),
1223 N_("Import Directory [parts of .idata]"),
1224 N_("Resource Directory [.rsrc]"),
1225 N_("Exception Directory [.pdata]"),
1226 N_("Security Directory"),
1227 N_("Base Relocation Directory [.reloc]"),
1228 N_("Debug Directory"),
1229 N_("Description Directory"),
1230 N_("Special Directory"),
1231 N_("Thread Storage Directory [.tls]"),
1232 N_("Load Configuration Directory"),
1233 N_("Bound Import Directory"),
1234 N_("Import Address Table Directory"),
1235 N_("Delay Import Directory"),
1236 N_("CLR Runtime Header"),
1241 pe_print_idata (bfd
* abfd
, void * vfile
)
1243 FILE *file
= (FILE *) vfile
;
1247 bfd_size_type datasize
= 0;
1248 bfd_size_type dataoff
;
1252 pe_data_type
*pe
= pe_data (abfd
);
1253 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1257 addr
= extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
;
1259 if (addr
== 0 && extra
->DataDirectory
[PE_IMPORT_TABLE
].Size
== 0)
1261 /* Maybe the extra header isn't there. Look for the section. */
1262 section
= bfd_get_section_by_name (abfd
, ".idata");
1263 if (section
== NULL
)
1266 addr
= section
->vma
;
1267 datasize
= section
->size
;
1273 addr
+= extra
->ImageBase
;
1274 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1276 datasize
= section
->size
;
1277 if (addr
>= section
->vma
&& addr
< section
->vma
+ datasize
)
1281 if (section
== NULL
)
1284 _("\nThere is an import table, but the section containing it could not be found\n"));
1287 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1290 _("\nThere is an import table in %s, but that section has no contents\n"),
1296 /* xgettext:c-format */
1297 fprintf (file
, _("\nThere is an import table in %s at 0x%lx\n"),
1298 section
->name
, (unsigned long) addr
);
1300 dataoff
= addr
- section
->vma
;
1303 _("\nThe Import Tables (interpreted %s section contents)\n"),
1307 vma: Hint Time Forward DLL First\n\
1308 Table Stamp Chain Name Thunk\n"));
1310 /* Read the whole section. Some of the fields might be before dataoff. */
1311 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
1317 adj
= section
->vma
- extra
->ImageBase
;
1319 /* Print all image import descriptors. */
1320 for (i
= dataoff
; i
+ onaline
<= datasize
; i
+= onaline
)
1324 bfd_vma forward_chain
;
1326 bfd_vma first_thunk
;
1331 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1332 fprintf (file
, " %08lx\t", (unsigned long) (i
+ adj
));
1333 hint_addr
= bfd_get_32 (abfd
, data
+ i
);
1334 time_stamp
= bfd_get_32 (abfd
, data
+ i
+ 4);
1335 forward_chain
= bfd_get_32 (abfd
, data
+ i
+ 8);
1336 dll_name
= bfd_get_32 (abfd
, data
+ i
+ 12);
1337 first_thunk
= bfd_get_32 (abfd
, data
+ i
+ 16);
1339 fprintf (file
, "%08lx %08lx %08lx %08lx %08lx\n",
1340 (unsigned long) hint_addr
,
1341 (unsigned long) time_stamp
,
1342 (unsigned long) forward_chain
,
1343 (unsigned long) dll_name
,
1344 (unsigned long) first_thunk
);
1346 if (hint_addr
== 0 && first_thunk
== 0)
1349 if (dll_name
- adj
>= section
->size
)
1352 dll
= (char *) data
+ dll_name
- adj
;
1353 /* PR 17512 file: 078-12277-0.004. */
1354 bfd_size_type maxlen
= (char *)(data
+ datasize
) - dll
- 1;
1355 fprintf (file
, _("\n\tDLL Name: %.*s\n"), (int) maxlen
, dll
);
1357 /* PR 21546: When the Hint Address is zero,
1358 we try the First Thunk instead. */
1360 hint_addr
= first_thunk
;
1362 if (hint_addr
!= 0 && hint_addr
- adj
< datasize
)
1365 asection
*ft_section
;
1367 bfd_size_type ft_datasize
;
1371 fprintf (file
, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1373 idx
= hint_addr
- adj
;
1375 ft_addr
= first_thunk
+ extra
->ImageBase
;
1376 ft_idx
= first_thunk
- adj
;
1377 ft_data
= data
+ ft_idx
;
1378 ft_datasize
= datasize
- ft_idx
;
1381 if (first_thunk
!= hint_addr
)
1383 /* Find the section which contains the first thunk. */
1384 for (ft_section
= abfd
->sections
;
1386 ft_section
= ft_section
->next
)
1388 if (ft_addr
>= ft_section
->vma
1389 && ft_addr
< ft_section
->vma
+ ft_section
->size
)
1393 if (ft_section
== NULL
)
1396 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1400 /* Now check to see if this section is the same as our current
1401 section. If it is not then we will have to load its data in. */
1402 if (ft_section
!= section
)
1404 ft_idx
= first_thunk
- (ft_section
->vma
- extra
->ImageBase
);
1405 ft_datasize
= ft_section
->size
- ft_idx
;
1406 ft_data
= (bfd_byte
*) bfd_malloc (ft_datasize
);
1407 if (ft_data
== NULL
)
1410 /* Read ft_datasize bytes starting at offset ft_idx. */
1411 if (!bfd_get_section_contents (abfd
, ft_section
, ft_data
,
1412 (bfd_vma
) ft_idx
, ft_datasize
))
1421 /* Print HintName vector entries. */
1422 #ifdef COFF_WITH_pex64
1423 for (j
= 0; idx
+ j
+ 8 <= datasize
; j
+= 8)
1426 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1427 unsigned long member_high
= bfd_get_32 (abfd
, data
+ idx
+ j
+ 4);
1429 if (!member
&& !member_high
)
1434 if (HighBitSet (member_high
))
1435 fprintf (file
, "\t%lx%08lx\t %4lx%08lx <none>",
1436 member_high
, member
,
1437 WithoutHighBit (member_high
), member
);
1438 /* PR binutils/17512: Handle corrupt PE data. */
1439 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1440 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1446 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1447 member_name
= (char *) data
+ amt
+ 2;
1448 fprintf (file
, "\t%04lx\t %4d %.*s",member
, ordinal
,
1449 (int) (datasize
- (amt
+ 2)), member_name
);
1452 /* If the time stamp is not zero, the import address
1453 table holds actual addresses. */
1456 && first_thunk
!= hint_addr
1457 && j
+ 4 <= ft_datasize
)
1458 fprintf (file
, "\t%04lx",
1459 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1460 fprintf (file
, "\n");
1463 for (j
= 0; idx
+ j
+ 4 <= datasize
; j
+= 4)
1466 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1468 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1474 if (HighBitSet (member
))
1475 fprintf (file
, "\t%04lx\t %4lu <none>",
1476 member
, WithoutHighBit (member
));
1477 /* PR binutils/17512: Handle corrupt PE data. */
1478 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1479 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1485 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1486 member_name
= (char *) data
+ amt
+ 2;
1487 fprintf (file
, "\t%04lx\t %4d %.*s",
1489 (int) (datasize
- (amt
+ 2)), member_name
);
1492 /* If the time stamp is not zero, the import address
1493 table holds actual addresses. */
1496 && first_thunk
!= hint_addr
1497 && j
+ 4 <= ft_datasize
)
1498 fprintf (file
, "\t%04lx",
1499 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1501 fprintf (file
, "\n");
1508 fprintf (file
, "\n");
1517 pe_print_edata (bfd
* abfd
, void * vfile
)
1519 FILE *file
= (FILE *) vfile
;
1522 bfd_size_type datasize
= 0;
1523 bfd_size_type dataoff
;
1528 long export_flags
; /* Reserved - should be zero. */
1532 bfd_vma name
; /* RVA - relative to image base. */
1533 long base
; /* Ordinal base. */
1534 unsigned long num_functions
;/* Number in the export address table. */
1535 unsigned long num_names
; /* Number in the name pointer table. */
1536 bfd_vma eat_addr
; /* RVA to the export address table. */
1537 bfd_vma npt_addr
; /* RVA to the Export Name Pointer Table. */
1538 bfd_vma ot_addr
; /* RVA to the Ordinal Table. */
1541 pe_data_type
*pe
= pe_data (abfd
);
1542 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1546 addr
= extra
->DataDirectory
[PE_EXPORT_TABLE
].VirtualAddress
;
1548 if (addr
== 0 && extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
== 0)
1550 /* Maybe the extra header isn't there. Look for the section. */
1551 section
= bfd_get_section_by_name (abfd
, ".edata");
1552 if (section
== NULL
)
1555 addr
= section
->vma
;
1557 datasize
= section
->size
;
1563 addr
+= extra
->ImageBase
;
1565 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1566 if (addr
>= section
->vma
&& addr
< section
->vma
+ section
->size
)
1569 if (section
== NULL
)
1572 _("\nThere is an export table, but the section containing it could not be found\n"));
1575 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1578 _("\nThere is an export table in %s, but that section has no contents\n"),
1583 dataoff
= addr
- section
->vma
;
1584 datasize
= extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
;
1585 if (dataoff
> section
->size
1586 || datasize
> section
->size
- dataoff
)
1589 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1595 /* PR 17512: Handle corrupt PE binaries. */
1599 /* xgettext:c-format */
1600 _("\nThere is an export table in %s, but it is too small (%d)\n"),
1601 section
->name
, (int) datasize
);
1605 /* xgettext:c-format */
1606 fprintf (file
, _("\nThere is an export table in %s at 0x%lx\n"),
1607 section
->name
, (unsigned long) addr
);
1609 data
= (bfd_byte
*) bfd_malloc (datasize
);
1613 if (! bfd_get_section_contents (abfd
, section
, data
,
1614 (file_ptr
) dataoff
, datasize
))
1617 /* Go get Export Directory Table. */
1618 edt
.export_flags
= bfd_get_32 (abfd
, data
+ 0);
1619 edt
.time_stamp
= bfd_get_32 (abfd
, data
+ 4);
1620 edt
.major_ver
= bfd_get_16 (abfd
, data
+ 8);
1621 edt
.minor_ver
= bfd_get_16 (abfd
, data
+ 10);
1622 edt
.name
= bfd_get_32 (abfd
, data
+ 12);
1623 edt
.base
= bfd_get_32 (abfd
, data
+ 16);
1624 edt
.num_functions
= bfd_get_32 (abfd
, data
+ 20);
1625 edt
.num_names
= bfd_get_32 (abfd
, data
+ 24);
1626 edt
.eat_addr
= bfd_get_32 (abfd
, data
+ 28);
1627 edt
.npt_addr
= bfd_get_32 (abfd
, data
+ 32);
1628 edt
.ot_addr
= bfd_get_32 (abfd
, data
+ 36);
1630 adj
= section
->vma
- extra
->ImageBase
+ dataoff
;
1632 /* Dump the EDT first. */
1634 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1638 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt
.export_flags
);
1641 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt
.time_stamp
);
1644 /* xgettext:c-format */
1645 _("Major/Minor \t\t\t%d/%d\n"), edt
.major_ver
, edt
.minor_ver
);
1648 _("Name \t\t\t\t"));
1649 bfd_fprintf_vma (abfd
, file
, edt
.name
);
1651 if ((edt
.name
>= adj
) && (edt
.name
< adj
+ datasize
))
1652 fprintf (file
, " %.*s\n",
1653 (int) (datasize
- (edt
.name
- adj
)),
1654 data
+ edt
.name
- adj
);
1656 fprintf (file
, "(outside .edata section)\n");
1659 _("Ordinal Base \t\t\t%ld\n"), edt
.base
);
1665 _("\tExport Address Table \t\t%08lx\n"),
1669 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt
.num_names
);
1672 _("Table Addresses\n"));
1675 _("\tExport Address Table \t\t"));
1676 bfd_fprintf_vma (abfd
, file
, edt
.eat_addr
);
1677 fprintf (file
, "\n");
1680 _("\tName Pointer Table \t\t"));
1681 bfd_fprintf_vma (abfd
, file
, edt
.npt_addr
);
1682 fprintf (file
, "\n");
1685 _("\tOrdinal Table \t\t\t"));
1686 bfd_fprintf_vma (abfd
, file
, edt
.ot_addr
);
1687 fprintf (file
, "\n");
1689 /* The next table to find is the Export Address Table. It's basically
1690 a list of pointers that either locate a function in this dll, or
1691 forward the call to another dll. Something like:
1696 } export_address_table_entry; */
1699 _("\nExport Address Table -- Ordinal Base %ld\n"),
1702 /* PR 17512: Handle corrupt PE binaries. */
1703 /* PR 17512 file: 140-165018-0.004. */
1704 if (edt
.eat_addr
- adj
>= datasize
1705 /* PR 17512: file: 092b1829 */
1706 || (edt
.num_functions
+ 1) * 4 < edt
.num_functions
1707 || edt
.eat_addr
- adj
+ (edt
.num_functions
+ 1) * 4 > datasize
)
1708 fprintf (file
, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1709 (long) edt
.eat_addr
,
1710 (long) edt
.num_functions
);
1711 else for (i
= 0; i
< edt
.num_functions
; ++i
)
1713 bfd_vma eat_member
= bfd_get_32 (abfd
,
1714 data
+ edt
.eat_addr
+ (i
* 4) - adj
);
1715 if (eat_member
== 0)
1718 if (eat_member
- adj
<= datasize
)
1720 /* This rva is to a name (forwarding function) in our section. */
1721 /* Should locate a function descriptor. */
1723 "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1725 (long) (i
+ edt
.base
),
1726 (unsigned long) eat_member
,
1728 (int)(datasize
- (eat_member
- adj
)),
1729 data
+ eat_member
- adj
);
1733 /* Should locate a function descriptor in the reldata section. */
1735 "\t[%4ld] +base[%4ld] %04lx %s\n",
1737 (long) (i
+ edt
.base
),
1738 (unsigned long) eat_member
,
1743 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1744 /* Dump them in parallel for clarity. */
1746 _("\n[Ordinal/Name Pointer] Table\n"));
1748 /* PR 17512: Handle corrupt PE binaries. */
1749 if (edt
.npt_addr
+ (edt
.num_names
* 4) - adj
>= datasize
1750 /* PR 17512: file: bb68816e. */
1751 || edt
.num_names
* 4 < edt
.num_names
1752 || (data
+ edt
.npt_addr
- adj
) < data
)
1753 /* xgettext:c-format */
1754 fprintf (file
, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1755 (long) edt
.npt_addr
,
1756 (long) edt
.num_names
);
1757 /* PR 17512: file: 140-147171-0.004. */
1758 else if (edt
.ot_addr
+ (edt
.num_names
* 2) - adj
>= datasize
1759 || data
+ edt
.ot_addr
- adj
< data
)
1760 /* xgettext:c-format */
1761 fprintf (file
, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1763 (long) edt
.num_names
);
1764 else for (i
= 0; i
< edt
.num_names
; ++i
)
1769 ord
= bfd_get_16 (abfd
, data
+ edt
.ot_addr
+ (i
* 2) - adj
);
1770 name_ptr
= bfd_get_32 (abfd
, data
+ edt
.npt_addr
+ (i
* 4) - adj
);
1772 if ((name_ptr
- adj
) >= datasize
)
1774 /* xgettext:c-format */
1775 fprintf (file
, _("\t[%4ld] <corrupt offset: %lx>\n"),
1776 (long) ord
, (long) name_ptr
);
1780 char * name
= (char *) data
+ name_ptr
- adj
;
1782 fprintf (file
, "\t[%4ld] %.*s\n", (long) ord
,
1783 (int)((char *)(data
+ datasize
) - name
), name
);
1792 /* This really is architecture dependent. On IA-64, a .pdata entry
1793 consists of three dwords containing relative virtual addresses that
1794 specify the start and end address of the code range the entry
1795 covers and the address of the corresponding unwind info data.
1797 On ARM and SH-4, a compressed PDATA structure is used :
1798 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1799 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1800 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1802 This is the version for uncompressed data. */
1805 pe_print_pdata (bfd
* abfd
, void * vfile
)
1807 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1808 # define PDATA_ROW_SIZE (3 * 8)
1810 # define PDATA_ROW_SIZE (5 * 4)
1812 FILE *file
= (FILE *) vfile
;
1814 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1815 bfd_size_type datasize
= 0;
1817 bfd_size_type start
, stop
;
1818 int onaline
= PDATA_ROW_SIZE
;
1821 || coff_section_data (abfd
, section
) == NULL
1822 || pei_section_data (abfd
, section
) == NULL
)
1825 stop
= pei_section_data (abfd
, section
)->virt_size
;
1826 if ((stop
% onaline
) != 0)
1828 /* xgettext:c-format */
1829 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
1830 (long) stop
, onaline
);
1833 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1834 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1836 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1839 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1840 \t\tAddress Address Handler Data Address Mask\n"));
1843 datasize
= section
->size
;
1847 /* PR 17512: file: 002-193900-0.004. */
1848 if (datasize
< stop
)
1850 /* xgettext:c-format */
1851 fprintf (file
, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"),
1852 (long) stop
, (long) datasize
);
1856 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
1864 for (i
= start
; i
< stop
; i
+= onaline
)
1870 bfd_vma prolog_end_addr
;
1871 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1875 if (i
+ PDATA_ROW_SIZE
> stop
)
1878 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
1879 end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
1880 eh_handler
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 8);
1881 eh_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 12);
1882 prolog_end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 16);
1884 if (begin_addr
== 0 && end_addr
== 0 && eh_handler
== 0
1885 && eh_data
== 0 && prolog_end_addr
== 0)
1886 /* We are probably into the padding of the section now. */
1889 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1890 em_data
= ((eh_handler
& 0x1) << 2) | (prolog_end_addr
& 0x3);
1892 eh_handler
&= ~(bfd_vma
) 0x3;
1893 prolog_end_addr
&= ~(bfd_vma
) 0x3;
1896 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
1897 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
1898 bfd_fprintf_vma (abfd
, file
, end_addr
); fputc (' ', file
);
1899 bfd_fprintf_vma (abfd
, file
, eh_handler
);
1900 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1902 bfd_fprintf_vma (abfd
, file
, eh_data
); fputc (' ', file
);
1903 bfd_fprintf_vma (abfd
, file
, prolog_end_addr
);
1904 fprintf (file
, " %x", em_data
);
1906 fprintf (file
, "\n");
1912 #undef PDATA_ROW_SIZE
1915 typedef struct sym_cache
1922 slurp_symtab (bfd
*abfd
, sym_cache
*psc
)
1924 asymbol
** sy
= NULL
;
1927 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1933 storage
= bfd_get_symtab_upper_bound (abfd
);
1938 sy
= (asymbol
**) bfd_malloc (storage
);
1943 psc
->symcount
= bfd_canonicalize_symtab (abfd
, sy
);
1944 if (psc
->symcount
< 0)
1950 my_symbol_for_address (bfd
*abfd
, bfd_vma func
, sym_cache
*psc
)
1955 psc
->syms
= slurp_symtab (abfd
, psc
);
1957 for (i
= 0; i
< psc
->symcount
; i
++)
1959 if (psc
->syms
[i
]->section
->vma
+ psc
->syms
[i
]->value
== func
)
1960 return psc
->syms
[i
]->name
;
1967 cleanup_syms (sym_cache
*psc
)
1974 /* This is the version for "compressed" pdata. */
1977 _bfd_XX_print_ce_compressed_pdata (bfd
* abfd
, void * vfile
)
1979 # define PDATA_ROW_SIZE (2 * 4)
1980 FILE *file
= (FILE *) vfile
;
1981 bfd_byte
*data
= NULL
;
1982 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1983 bfd_size_type datasize
= 0;
1985 bfd_size_type start
, stop
;
1986 int onaline
= PDATA_ROW_SIZE
;
1987 struct sym_cache cache
= {0, 0} ;
1990 || coff_section_data (abfd
, section
) == NULL
1991 || pei_section_data (abfd
, section
) == NULL
)
1994 stop
= pei_section_data (abfd
, section
)->virt_size
;
1995 if ((stop
% onaline
) != 0)
1997 /* xgettext:c-format */
1998 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
1999 (long) stop
, onaline
);
2002 _("\nThe Function Table (interpreted .pdata section contents)\n"));
2005 vma:\t\tBegin Prolog Function Flags Exception EH\n\
2006 \t\tAddress Length Length 32b exc Handler Data\n"));
2008 datasize
= section
->size
;
2012 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2020 for (i
= start
; i
< stop
; i
+= onaline
)
2024 bfd_vma prolog_length
, function_length
;
2025 int flag32bit
, exception_flag
;
2028 if (i
+ PDATA_ROW_SIZE
> stop
)
2031 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
2032 other_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
2034 if (begin_addr
== 0 && other_data
== 0)
2035 /* We are probably into the padding of the section now. */
2038 prolog_length
= (other_data
& 0x000000FF);
2039 function_length
= (other_data
& 0x3FFFFF00) >> 8;
2040 flag32bit
= (int)((other_data
& 0x40000000) >> 30);
2041 exception_flag
= (int)((other_data
& 0x80000000) >> 31);
2044 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
2045 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
2046 bfd_fprintf_vma (abfd
, file
, prolog_length
); fputc (' ', file
);
2047 bfd_fprintf_vma (abfd
, file
, function_length
); fputc (' ', file
);
2048 fprintf (file
, "%2d %2d ", flag32bit
, exception_flag
);
2050 /* Get the exception handler's address and the data passed from the
2051 .text section. This is really the data that belongs with the .pdata
2052 but got "compressed" out for the ARM and SH4 architectures. */
2053 tsection
= bfd_get_section_by_name (abfd
, ".text");
2054 if (tsection
&& coff_section_data (abfd
, tsection
)
2055 && pei_section_data (abfd
, tsection
))
2057 bfd_vma eh_off
= (begin_addr
- 8) - tsection
->vma
;
2060 tdata
= (bfd_byte
*) bfd_malloc (8);
2063 if (bfd_get_section_contents (abfd
, tsection
, tdata
, eh_off
, 8))
2065 bfd_vma eh
, eh_data
;
2067 eh
= bfd_get_32 (abfd
, tdata
);
2068 eh_data
= bfd_get_32 (abfd
, tdata
+ 4);
2069 fprintf (file
, "%08x ", (unsigned int) eh
);
2070 fprintf (file
, "%08x", (unsigned int) eh_data
);
2073 const char *s
= my_symbol_for_address (abfd
, eh
, &cache
);
2076 fprintf (file
, " (%s) ", s
);
2083 fprintf (file
, "\n");
2088 cleanup_syms (& cache
);
2091 #undef PDATA_ROW_SIZE
2095 #define IMAGE_REL_BASED_HIGHADJ 4
2096 static const char * const tbl
[] =
2110 "UNKNOWN", /* MUST be last. */
2114 pe_print_reloc (bfd
* abfd
, void * vfile
)
2116 FILE *file
= (FILE *) vfile
;
2118 asection
*section
= bfd_get_section_by_name (abfd
, ".reloc");
2121 if (section
== NULL
|| section
->size
== 0 || !(section
->flags
& SEC_HAS_CONTENTS
))
2125 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2127 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2134 end
= data
+ section
->size
;
2135 while (p
+ 8 <= end
)
2138 bfd_vma virtual_address
;
2139 unsigned long number
, size
;
2140 bfd_byte
*chunk_end
;
2142 /* The .reloc section is a sequence of blocks, with a header consisting
2143 of two 32 bit quantities, followed by a number of 16 bit entries. */
2144 virtual_address
= bfd_get_32 (abfd
, p
);
2145 size
= bfd_get_32 (abfd
, p
+ 4);
2147 number
= (size
- 8) / 2;
2153 /* xgettext:c-format */
2154 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2155 (unsigned long) virtual_address
, size
, size
, number
);
2157 chunk_end
= p
- 8 + size
;
2158 if (chunk_end
> end
)
2161 while (p
+ 2 <= chunk_end
)
2163 unsigned short e
= bfd_get_16 (abfd
, p
);
2164 unsigned int t
= (e
& 0xF000) >> 12;
2165 int off
= e
& 0x0FFF;
2167 if (t
>= sizeof (tbl
) / sizeof (tbl
[0]))
2168 t
= (sizeof (tbl
) / sizeof (tbl
[0])) - 1;
2171 /* xgettext:c-format */
2172 _("\treloc %4d offset %4x [%4lx] %s"),
2173 j
, off
, (unsigned long) (off
+ virtual_address
), tbl
[t
]);
2178 /* HIGHADJ takes an argument, - the next record *is* the
2179 low 16 bits of addend. */
2180 if (t
== IMAGE_REL_BASED_HIGHADJ
&& p
+ 2 <= chunk_end
)
2182 fprintf (file
, " (%4x)", (unsigned int) bfd_get_16 (abfd
, p
));
2187 fprintf (file
, "\n");
2196 /* A data structure describing the regions of a .rsrc section.
2197 Some fields are filled in as the section is parsed. */
2199 typedef struct rsrc_regions
2201 bfd_byte
* section_start
;
2202 bfd_byte
* section_end
;
2203 bfd_byte
* strings_start
;
2204 bfd_byte
* resource_start
;
2208 rsrc_print_resource_directory (FILE * , bfd
*, unsigned int, bfd_byte
*,
2209 rsrc_regions
*, bfd_vma
);
2211 /* Print the resource entry at DATA, with the text indented by INDENT.
2212 Recusively calls rsrc_print_resource_directory to print the contents
2213 of directory entries.
2214 Returns the address of the end of the data associated with the entry
2215 or section_end + 1 upon failure. */
2218 rsrc_print_resource_entries (FILE * file
,
2220 unsigned int indent
,
2221 bfd_boolean is_name
,
2223 rsrc_regions
* regions
,
2226 unsigned long entry
, addr
, size
;
2229 if (data
+ 8 >= regions
->section_end
)
2230 return regions
->section_end
+ 1;
2232 /* xgettext:c-format */
2233 fprintf (file
, _("%03x %*.s Entry: "), (int)(data
- regions
->section_start
), indent
, " ");
2235 entry
= (unsigned long) bfd_get_32 (abfd
, data
);
2240 /* Note - the documentation says that this field is an RVA value
2241 but windres appears to produce a section relative offset with
2242 the top bit set. Support both styles for now. */
2243 if (HighBitSet (entry
))
2244 name
= regions
->section_start
+ WithoutHighBit (entry
);
2246 name
= regions
->section_start
+ entry
- rva_bias
;
2248 if (name
+ 2 < regions
->section_end
&& name
> regions
->section_start
)
2252 if (regions
->strings_start
== NULL
)
2253 regions
->strings_start
= name
;
2255 len
= bfd_get_16 (abfd
, name
);
2257 fprintf (file
, _("name: [val: %08lx len %d]: "), entry
, len
);
2259 if (name
+ 2 + len
* 2 < regions
->section_end
)
2261 /* This strange loop is to cope with multibyte characters. */
2268 /* Avoid printing control characters. */
2269 if (c
> 0 && c
< 32)
2270 fprintf (file
, "^%c", c
+ 64);
2272 fprintf (file
, "%.1s", name
);
2277 fprintf (file
, _("<corrupt string length: %#x>\n"), len
);
2278 /* PR binutils/17512: Do not try to continue decoding a
2279 corrupted resource section. It is likely to end up with
2280 reams of extraneous output. FIXME: We could probably
2281 continue if we disable the printing of strings... */
2282 return regions
->section_end
+ 1;
2287 fprintf (file
, _("<corrupt string offset: %#lx>\n"), entry
);
2288 return regions
->section_end
+ 1;
2292 fprintf (file
, _("ID: %#08lx"), entry
);
2294 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
2295 fprintf (file
, _(", Value: %#08lx\n"), entry
);
2297 if (HighBitSet (entry
))
2299 data
= regions
->section_start
+ WithoutHighBit (entry
);
2300 if (data
<= regions
->section_start
|| data
> regions
->section_end
)
2301 return regions
->section_end
+ 1;
2303 /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2304 in the resource table. We need some way to detect this. */
2305 return rsrc_print_resource_directory (file
, abfd
, indent
+ 1, data
,
2309 leaf
= regions
->section_start
+ entry
;
2311 if (leaf
+ 16 >= regions
->section_end
2312 /* PR 17512: file: 055dff7e. */
2313 || leaf
< regions
->section_start
)
2314 return regions
->section_end
+ 1;
2316 /* xgettext:c-format */
2317 fprintf (file
, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2318 (int) (entry
), indent
, " ",
2319 addr
= (long) bfd_get_32 (abfd
, leaf
),
2320 size
= (long) bfd_get_32 (abfd
, leaf
+ 4),
2321 (int) bfd_get_32 (abfd
, leaf
+ 8));
2323 /* Check that the reserved entry is 0. */
2324 if (bfd_get_32 (abfd
, leaf
+ 12) != 0
2325 /* And that the data address/size is valid too. */
2326 || (regions
->section_start
+ (addr
- rva_bias
) + size
> regions
->section_end
))
2327 return regions
->section_end
+ 1;
2329 if (regions
->resource_start
== NULL
)
2330 regions
->resource_start
= regions
->section_start
+ (addr
- rva_bias
);
2332 return regions
->section_start
+ (addr
- rva_bias
) + size
;
2335 #define max(a,b) ((a) > (b) ? (a) : (b))
2336 #define min(a,b) ((a) < (b) ? (a) : (b))
2339 rsrc_print_resource_directory (FILE * file
,
2341 unsigned int indent
,
2343 rsrc_regions
* regions
,
2346 unsigned int num_names
, num_ids
;
2347 bfd_byte
* highest_data
= data
;
2349 if (data
+ 16 >= regions
->section_end
)
2350 return regions
->section_end
+ 1;
2352 fprintf (file
, "%03x %*.s ", (int)(data
- regions
->section_start
), indent
, " ");
2355 case 0: fprintf (file
, "Type"); break;
2356 case 2: fprintf (file
, "Name"); break;
2357 case 4: fprintf (file
, "Language"); break;
2359 fprintf (file
, _("<unknown directory type: %d>\n"), indent
);
2360 /* FIXME: For now we end the printing here. If in the
2361 future more directory types are added to the RSRC spec
2362 then we will need to change this. */
2363 return regions
->section_end
+ 1;
2366 /* xgettext:c-format */
2367 fprintf (file
, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2368 (int) bfd_get_32 (abfd
, data
),
2369 (long) bfd_get_32 (abfd
, data
+ 4),
2370 (int) bfd_get_16 (abfd
, data
+ 8),
2371 (int) bfd_get_16 (abfd
, data
+ 10),
2372 num_names
= (int) bfd_get_16 (abfd
, data
+ 12),
2373 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14));
2376 while (num_names
--)
2378 bfd_byte
* entry_end
;
2380 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, TRUE
,
2381 data
, regions
, rva_bias
);
2383 highest_data
= max (highest_data
, entry_end
);
2384 if (entry_end
>= regions
->section_end
)
2390 bfd_byte
* entry_end
;
2392 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, FALSE
,
2393 data
, regions
, rva_bias
);
2395 highest_data
= max (highest_data
, entry_end
);
2396 if (entry_end
>= regions
->section_end
)
2400 return max (highest_data
, data
);
2403 /* Display the contents of a .rsrc section. We do not try to
2404 reproduce the resources, windres does that. Instead we dump
2405 the tables in a human readable format. */
2408 rsrc_print_section (bfd
* abfd
, void * vfile
)
2412 FILE * file
= (FILE *) vfile
;
2413 bfd_size_type datasize
;
2416 rsrc_regions regions
;
2418 pe
= pe_data (abfd
);
2422 section
= bfd_get_section_by_name (abfd
, ".rsrc");
2423 if (section
== NULL
)
2425 if (!(section
->flags
& SEC_HAS_CONTENTS
))
2428 datasize
= section
->size
;
2432 rva_bias
= section
->vma
- pe
->pe_opthdr
.ImageBase
;
2434 if (! bfd_malloc_and_get_section (abfd
, section
, & data
))
2440 regions
.section_start
= data
;
2441 regions
.section_end
= data
+ datasize
;
2442 regions
.strings_start
= NULL
;
2443 regions
.resource_start
= NULL
;
2446 fprintf (file
, "\nThe .rsrc Resource Directory section:\n");
2448 while (data
< regions
.section_end
)
2450 bfd_byte
* p
= data
;
2452 data
= rsrc_print_resource_directory (file
, abfd
, 0, data
, & regions
, rva_bias
);
2454 if (data
== regions
.section_end
+ 1)
2455 fprintf (file
, _("Corrupt .rsrc section detected!\n"));
2458 /* Align data before continuing. */
2459 int align
= (1 << section
->alignment_power
) - 1;
2461 data
= (bfd_byte
*) (((ptrdiff_t) (data
+ align
)) & ~ align
);
2462 rva_bias
+= data
- p
;
2464 /* For reasons that are unclear .rsrc sections are sometimes created
2465 aligned to a 1^3 boundary even when their alignment is set at
2466 1^2. Catch that case here before we issue a spurious warning
2468 if (data
== (regions
.section_end
- 4))
2469 data
= regions
.section_end
;
2470 else if (data
< regions
.section_end
)
2472 /* If the extra data is all zeros then do not complain.
2473 This is just padding so that the section meets the
2474 page size requirements. */
2475 while (++ data
< regions
.section_end
)
2478 if (data
< regions
.section_end
)
2479 fprintf (file
, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2484 if (regions
.strings_start
!= NULL
)
2485 fprintf (file
, _(" String table starts at offset: %#03x\n"),
2486 (int) (regions
.strings_start
- regions
.section_start
));
2487 if (regions
.resource_start
!= NULL
)
2488 fprintf (file
, _(" Resources start at offset: %#03x\n"),
2489 (int) (regions
.resource_start
- regions
.section_start
));
2491 free (regions
.section_start
);
2495 #define IMAGE_NUMBEROF_DEBUG_TYPES 17
2497 static char * debug_type_names
[IMAGE_NUMBEROF_DEBUG_TYPES
] =
2519 pe_print_debugdata (bfd
* abfd
, void * vfile
)
2521 FILE *file
= (FILE *) vfile
;
2522 pe_data_type
*pe
= pe_data (abfd
);
2523 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2526 bfd_size_type dataoff
;
2529 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2530 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2535 addr
+= extra
->ImageBase
;
2536 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2538 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2542 if (section
== NULL
)
2545 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2548 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
2551 _("\nThere is a debug directory in %s, but that section has no contents\n"),
2555 else if (section
->size
< size
)
2558 _("\nError: section %s contains the debug data starting address but it is too small\n"),
2563 fprintf (file
, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2564 section
->name
, (unsigned long) addr
);
2566 dataoff
= addr
- section
->vma
;
2568 if (size
> (section
->size
- dataoff
))
2570 fprintf (file
, _("The debug data size field in the data directory is too big for the section"));
2575 _("Type Size Rva Offset\n"));
2577 /* Read the whole section. */
2578 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2584 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2586 const char *type_name
;
2587 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2588 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2589 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2591 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2593 if ((idd
.Type
) >= IMAGE_NUMBEROF_DEBUG_TYPES
)
2594 type_name
= debug_type_names
[0];
2596 type_name
= debug_type_names
[idd
.Type
];
2598 fprintf (file
, " %2ld %14s %08lx %08lx %08lx\n",
2599 idd
.Type
, type_name
, idd
.SizeOfData
,
2600 idd
.AddressOfRawData
, idd
.PointerToRawData
);
2602 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_CODEVIEW
)
2604 char signature
[CV_INFO_SIGNATURE_LENGTH
* 2 + 1];
2605 /* PR 17512: file: 065-29434-0.001:0.1
2606 We need to use a 32-bit aligned buffer
2607 to safely read in a codeview record. */
2608 char buffer
[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO
);
2610 CODEVIEW_INFO
*cvinfo
= (CODEVIEW_INFO
*) buffer
;
2612 /* The debug entry doesn't have to have to be in a section,
2613 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2614 if (!_bfd_XXi_slurp_codeview_record (abfd
, (file_ptr
) idd
.PointerToRawData
,
2615 idd
.SizeOfData
, cvinfo
))
2618 for (j
= 0; j
< cvinfo
->SignatureLength
; j
++)
2619 sprintf (&signature
[j
*2], "%02x", cvinfo
->Signature
[j
] & 0xff);
2621 /* xgettext:c-format */
2622 fprintf (file
, _("(format %c%c%c%c signature %s age %ld)\n"),
2623 buffer
[0], buffer
[1], buffer
[2], buffer
[3],
2624 signature
, cvinfo
->Age
);
2630 if (size
% sizeof (struct external_IMAGE_DEBUG_DIRECTORY
) != 0)
2632 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2638 pe_is_repro (bfd
* abfd
)
2640 pe_data_type
*pe
= pe_data (abfd
);
2641 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2644 bfd_size_type dataoff
;
2646 bfd_boolean res
= FALSE
;
2648 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2649 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2654 addr
+= extra
->ImageBase
;
2655 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2657 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2661 if ((section
== NULL
)
2662 || (!(section
->flags
& SEC_HAS_CONTENTS
))
2663 || (section
->size
< size
))
2668 dataoff
= addr
- section
->vma
;
2670 if (size
> (section
->size
- dataoff
))
2675 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2681 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2683 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2684 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2685 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2687 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2689 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_REPRO
)
2701 /* Print out the program headers. */
2704 _bfd_XX_print_private_bfd_data_common (bfd
* abfd
, void * vfile
)
2706 FILE *file
= (FILE *) vfile
;
2708 pe_data_type
*pe
= pe_data (abfd
);
2709 struct internal_extra_pe_aouthdr
*i
= &pe
->pe_opthdr
;
2710 const char *subsystem_name
= NULL
;
2713 /* The MS dumpbin program reportedly ands with 0xff0f before
2714 printing the characteristics field. Not sure why. No reason to
2716 fprintf (file
, _("\nCharacteristics 0x%x\n"), pe
->real_flags
);
2718 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2719 PF (IMAGE_FILE_RELOCS_STRIPPED
, "relocations stripped");
2720 PF (IMAGE_FILE_EXECUTABLE_IMAGE
, "executable");
2721 PF (IMAGE_FILE_LINE_NUMS_STRIPPED
, "line numbers stripped");
2722 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED
, "symbols stripped");
2723 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE
, "large address aware");
2724 PF (IMAGE_FILE_BYTES_REVERSED_LO
, "little endian");
2725 PF (IMAGE_FILE_32BIT_MACHINE
, "32 bit words");
2726 PF (IMAGE_FILE_DEBUG_STRIPPED
, "debugging information removed");
2727 PF (IMAGE_FILE_SYSTEM
, "system file");
2728 PF (IMAGE_FILE_DLL
, "DLL");
2729 PF (IMAGE_FILE_BYTES_REVERSED_HI
, "big endian");
2733 If a PE_IMAGE_DEBUG_TYPE_REPRO entry is present in the debug directory, the
2734 timestamp is to be interpreted as the hash of a reproducible build.
2736 if (pe_is_repro (abfd
))
2738 fprintf (file
, "\nTime/Date\t\t%08lx", pe
->coff
.timestamp
);
2739 fprintf (file
, "\t(This is a reproducible build file hash, not a timestamp)\n");
2743 /* ctime implies '\n'. */
2744 time_t t
= pe
->coff
.timestamp
;
2745 fprintf (file
, "\nTime/Date\t\t%s", ctime (&t
));
2748 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2749 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2751 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2752 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2754 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2755 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2760 case IMAGE_NT_OPTIONAL_HDR_MAGIC
:
2763 case IMAGE_NT_OPTIONAL_HDR64_MAGIC
:
2766 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC
:
2773 fprintf (file
, "Magic\t\t\t%04x", i
->Magic
);
2775 fprintf (file
, "\t(%s)",name
);
2776 fprintf (file
, "\nMajorLinkerVersion\t%d\n", i
->MajorLinkerVersion
);
2777 fprintf (file
, "MinorLinkerVersion\t%d\n", i
->MinorLinkerVersion
);
2778 fprintf (file
, "SizeOfCode\t\t");
2779 bfd_fprintf_vma (abfd
, file
, i
->SizeOfCode
);
2780 fprintf (file
, "\nSizeOfInitializedData\t");
2781 bfd_fprintf_vma (abfd
, file
, i
->SizeOfInitializedData
);
2782 fprintf (file
, "\nSizeOfUninitializedData\t");
2783 bfd_fprintf_vma (abfd
, file
, i
->SizeOfUninitializedData
);
2784 fprintf (file
, "\nAddressOfEntryPoint\t");
2785 bfd_fprintf_vma (abfd
, file
, i
->AddressOfEntryPoint
);
2786 fprintf (file
, "\nBaseOfCode\t\t");
2787 bfd_fprintf_vma (abfd
, file
, i
->BaseOfCode
);
2788 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2789 /* PE32+ does not have BaseOfData member! */
2790 fprintf (file
, "\nBaseOfData\t\t");
2791 bfd_fprintf_vma (abfd
, file
, i
->BaseOfData
);
2794 fprintf (file
, "\nImageBase\t\t");
2795 bfd_fprintf_vma (abfd
, file
, i
->ImageBase
);
2796 fprintf (file
, "\nSectionAlignment\t%08x\n", i
->SectionAlignment
);
2797 fprintf (file
, "FileAlignment\t\t%08x\n", i
->FileAlignment
);
2798 fprintf (file
, "MajorOSystemVersion\t%d\n", i
->MajorOperatingSystemVersion
);
2799 fprintf (file
, "MinorOSystemVersion\t%d\n", i
->MinorOperatingSystemVersion
);
2800 fprintf (file
, "MajorImageVersion\t%d\n", i
->MajorImageVersion
);
2801 fprintf (file
, "MinorImageVersion\t%d\n", i
->MinorImageVersion
);
2802 fprintf (file
, "MajorSubsystemVersion\t%d\n", i
->MajorSubsystemVersion
);
2803 fprintf (file
, "MinorSubsystemVersion\t%d\n", i
->MinorSubsystemVersion
);
2804 fprintf (file
, "Win32Version\t\t%08x\n", i
->Reserved1
);
2805 fprintf (file
, "SizeOfImage\t\t%08x\n", i
->SizeOfImage
);
2806 fprintf (file
, "SizeOfHeaders\t\t%08x\n", i
->SizeOfHeaders
);
2807 fprintf (file
, "CheckSum\t\t%08x\n", i
->CheckSum
);
2809 switch (i
->Subsystem
)
2811 case IMAGE_SUBSYSTEM_UNKNOWN
:
2812 subsystem_name
= "unspecified";
2814 case IMAGE_SUBSYSTEM_NATIVE
:
2815 subsystem_name
= "NT native";
2817 case IMAGE_SUBSYSTEM_WINDOWS_GUI
:
2818 subsystem_name
= "Windows GUI";
2820 case IMAGE_SUBSYSTEM_WINDOWS_CUI
:
2821 subsystem_name
= "Windows CUI";
2823 case IMAGE_SUBSYSTEM_POSIX_CUI
:
2824 subsystem_name
= "POSIX CUI";
2826 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI
:
2827 subsystem_name
= "Wince CUI";
2829 /* These are from UEFI Platform Initialization Specification 1.1. */
2830 case IMAGE_SUBSYSTEM_EFI_APPLICATION
:
2831 subsystem_name
= "EFI application";
2833 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
:
2834 subsystem_name
= "EFI boot service driver";
2836 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
:
2837 subsystem_name
= "EFI runtime driver";
2839 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER
:
2840 subsystem_name
= "SAL runtime driver";
2842 /* This is from revision 8.0 of the MS PE/COFF spec */
2843 case IMAGE_SUBSYSTEM_XBOX
:
2844 subsystem_name
= "XBOX";
2846 /* Added default case for clarity - subsystem_name is NULL anyway. */
2848 subsystem_name
= NULL
;
2851 fprintf (file
, "Subsystem\t\t%08x", i
->Subsystem
);
2853 fprintf (file
, "\t(%s)", subsystem_name
);
2854 fprintf (file
, "\nDllCharacteristics\t%08x\n", i
->DllCharacteristics
);
2855 fprintf (file
, "SizeOfStackReserve\t");
2856 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackReserve
);
2857 fprintf (file
, "\nSizeOfStackCommit\t");
2858 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackCommit
);
2859 fprintf (file
, "\nSizeOfHeapReserve\t");
2860 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapReserve
);
2861 fprintf (file
, "\nSizeOfHeapCommit\t");
2862 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapCommit
);
2863 fprintf (file
, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i
->LoaderFlags
);
2864 fprintf (file
, "NumberOfRvaAndSizes\t%08lx\n",
2865 (unsigned long) i
->NumberOfRvaAndSizes
);
2867 fprintf (file
, "\nThe Data Directory\n");
2868 for (j
= 0; j
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; j
++)
2870 fprintf (file
, "Entry %1x ", j
);
2871 bfd_fprintf_vma (abfd
, file
, i
->DataDirectory
[j
].VirtualAddress
);
2872 fprintf (file
, " %08lx ", (unsigned long) i
->DataDirectory
[j
].Size
);
2873 fprintf (file
, "%s\n", dir_names
[j
]);
2876 pe_print_idata (abfd
, vfile
);
2877 pe_print_edata (abfd
, vfile
);
2878 if (bfd_coff_have_print_pdata (abfd
))
2879 bfd_coff_print_pdata (abfd
, vfile
);
2881 pe_print_pdata (abfd
, vfile
);
2882 pe_print_reloc (abfd
, vfile
);
2883 pe_print_debugdata (abfd
, file
);
2885 rsrc_print_section (abfd
, vfile
);
2891 is_vma_in_section (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sect
, void *obj
)
2893 bfd_vma addr
= * (bfd_vma
*) obj
;
2894 return (addr
>= sect
->vma
) && (addr
< (sect
->vma
+ sect
->size
));
2898 find_section_by_vma (bfd
*abfd
, bfd_vma addr
)
2900 return bfd_sections_find_if (abfd
, is_vma_in_section
, (void *) & addr
);
2903 /* Copy any private info we understand from the input bfd
2904 to the output bfd. */
2907 _bfd_XX_bfd_copy_private_bfd_data_common (bfd
* ibfd
, bfd
* obfd
)
2909 pe_data_type
*ipe
, *ope
;
2911 /* One day we may try to grok other private data. */
2912 if (ibfd
->xvec
->flavour
!= bfd_target_coff_flavour
2913 || obfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
2916 ipe
= pe_data (ibfd
);
2917 ope
= pe_data (obfd
);
2919 /* pe_opthdr is copied in copy_object. */
2920 ope
->dll
= ipe
->dll
;
2922 /* Don't copy input subsystem if output is different from input. */
2923 if (obfd
->xvec
!= ibfd
->xvec
)
2924 ope
->pe_opthdr
.Subsystem
= IMAGE_SUBSYSTEM_UNKNOWN
;
2926 /* For strip: if we removed .reloc, we'll make a real mess of things
2927 if we don't remove this entry as well. */
2928 if (! pe_data (obfd
)->has_reloc_section
)
2930 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].VirtualAddress
= 0;
2931 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].Size
= 0;
2934 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2935 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2937 if (! pe_data (ibfd
)->has_reloc_section
2938 && ! (pe_data (ibfd
)->real_flags
& IMAGE_FILE_RELOCS_STRIPPED
))
2939 pe_data (obfd
)->dont_strip_reloc
= 1;
2941 memcpy (ope
->dos_message
, ipe
->dos_message
, sizeof (ope
->dos_message
));
2943 /* The file offsets contained in the debug directory need rewriting. */
2944 if (ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
!= 0)
2946 bfd_vma addr
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
2947 + ope
->pe_opthdr
.ImageBase
;
2948 /* In particular a .buildid section may overlap (in VA space) with
2949 whatever section comes ahead of it (largely because of section->size
2950 representing s_size, not virt_size). Therefore don't look for the
2951 section containing the first byte, but for that covering the last
2953 bfd_vma last
= addr
+ ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
- 1;
2954 asection
*section
= find_section_by_vma (obfd
, last
);
2957 /* PR 17512: file: 0f15796a. */
2958 if (section
&& addr
< section
->vma
)
2960 /* xgettext:c-format */
2962 (_("%pB: Data Directory (%lx bytes at %" PRIx64
") "
2963 "extends across section boundary at %" PRIx64
),
2964 obfd
, ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
,
2965 (uint64_t) addr
, (uint64_t) section
->vma
);
2969 if (section
&& bfd_malloc_and_get_section (obfd
, section
, &data
))
2972 struct external_IMAGE_DEBUG_DIRECTORY
*dd
=
2973 (struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ (addr
- section
->vma
));
2975 for (i
= 0; i
< ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
2976 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2978 asection
*ddsection
;
2979 struct external_IMAGE_DEBUG_DIRECTORY
*edd
= &(dd
[i
]);
2980 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2982 _bfd_XXi_swap_debugdir_in (obfd
, edd
, &idd
);
2984 if (idd
.AddressOfRawData
== 0)
2985 continue; /* RVA 0 means only offset is valid, not handled yet. */
2987 ddsection
= find_section_by_vma (obfd
, idd
.AddressOfRawData
+ ope
->pe_opthdr
.ImageBase
);
2989 continue; /* Not in a section! */
2991 idd
.PointerToRawData
= ddsection
->filepos
+ (idd
.AddressOfRawData
2992 + ope
->pe_opthdr
.ImageBase
) - ddsection
->vma
;
2994 _bfd_XXi_swap_debugdir_out (obfd
, &idd
, edd
);
2997 if (!bfd_set_section_contents (obfd
, section
, data
, 0, section
->size
))
2999 _bfd_error_handler (_("failed to update file offsets in debug directory"));
3007 _bfd_error_handler (_("%pB: failed to read debug data section"), obfd
);
3015 /* Copy private section data. */
3018 _bfd_XX_bfd_copy_private_section_data (bfd
*ibfd
,
3023 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
3024 || bfd_get_flavour (obfd
) != bfd_target_coff_flavour
)
3027 if (coff_section_data (ibfd
, isec
) != NULL
3028 && pei_section_data (ibfd
, isec
) != NULL
)
3030 if (coff_section_data (obfd
, osec
) == NULL
)
3032 size_t amt
= sizeof (struct coff_section_tdata
);
3033 osec
->used_by_bfd
= bfd_zalloc (obfd
, amt
);
3034 if (osec
->used_by_bfd
== NULL
)
3038 if (pei_section_data (obfd
, osec
) == NULL
)
3040 size_t amt
= sizeof (struct pei_section_tdata
);
3041 coff_section_data (obfd
, osec
)->tdata
= bfd_zalloc (obfd
, amt
);
3042 if (coff_section_data (obfd
, osec
)->tdata
== NULL
)
3046 pei_section_data (obfd
, osec
)->virt_size
=
3047 pei_section_data (ibfd
, isec
)->virt_size
;
3048 pei_section_data (obfd
, osec
)->pe_flags
=
3049 pei_section_data (ibfd
, isec
)->pe_flags
;
3056 _bfd_XX_get_symbol_info (bfd
* abfd
, asymbol
*symbol
, symbol_info
*ret
)
3058 coff_get_symbol_info (abfd
, symbol
, ret
);
3061 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
3063 sort_x64_pdata (const void *l
, const void *r
)
3065 const char *lp
= (const char *) l
;
3066 const char *rp
= (const char *) r
;
3068 vl
= bfd_getl32 (lp
); vr
= bfd_getl32 (rp
);
3070 return (vl
< vr
? -1 : 1);
3071 /* We compare just begin address. */
3076 /* Functions to process a .rsrc section. */
3078 static unsigned int sizeof_leaves
;
3079 static unsigned int sizeof_strings
;
3080 static unsigned int sizeof_tables_and_entries
;
3083 rsrc_count_directory (bfd
*, bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
3086 rsrc_count_entries (bfd
* abfd
,
3087 bfd_boolean is_name
,
3088 bfd_byte
* datastart
,
3093 unsigned long entry
, addr
, size
;
3095 if (data
+ 8 >= dataend
)
3102 entry
= (long) bfd_get_32 (abfd
, data
);
3104 if (HighBitSet (entry
))
3105 name
= datastart
+ WithoutHighBit (entry
);
3107 name
= datastart
+ entry
- rva_bias
;
3109 if (name
+ 2 >= dataend
|| name
< datastart
)
3112 unsigned int len
= bfd_get_16 (abfd
, name
);
3113 if (len
== 0 || len
> 256)
3117 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
3119 if (HighBitSet (entry
))
3121 data
= datastart
+ WithoutHighBit (entry
);
3123 if (data
<= datastart
|| data
>= dataend
)
3126 return rsrc_count_directory (abfd
, datastart
, data
, dataend
, rva_bias
);
3129 if (datastart
+ entry
+ 16 >= dataend
)
3132 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
);
3133 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4);
3135 return datastart
+ addr
- rva_bias
+ size
;
3139 rsrc_count_directory (bfd
* abfd
,
3140 bfd_byte
* datastart
,
3145 unsigned int num_entries
, num_ids
;
3146 bfd_byte
* highest_data
= data
;
3148 if (data
+ 16 >= dataend
)
3151 num_entries
= (int) bfd_get_16 (abfd
, data
+ 12);
3152 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14);
3154 num_entries
+= num_ids
;
3158 while (num_entries
--)
3160 bfd_byte
* entry_end
;
3162 entry_end
= rsrc_count_entries (abfd
, num_entries
>= num_ids
,
3163 datastart
, data
, dataend
, rva_bias
);
3165 highest_data
= max (highest_data
, entry_end
);
3166 if (entry_end
>= dataend
)
3170 return max (highest_data
, data
);
3173 typedef struct rsrc_dir_chain
3175 unsigned int num_entries
;
3176 struct rsrc_entry
* first_entry
;
3177 struct rsrc_entry
* last_entry
;
3180 typedef struct rsrc_directory
3182 unsigned int characteristics
;
3187 rsrc_dir_chain names
;
3190 struct rsrc_entry
* entry
;
3193 typedef struct rsrc_string
3199 typedef struct rsrc_leaf
3202 unsigned int codepage
;
3206 typedef struct rsrc_entry
3208 bfd_boolean is_name
;
3212 struct rsrc_string name
;
3218 struct rsrc_directory
* directory
;
3219 struct rsrc_leaf
* leaf
;
3222 struct rsrc_entry
* next_entry
;
3223 struct rsrc_directory
* parent
;
3227 rsrc_parse_directory (bfd
*, rsrc_directory
*, bfd_byte
*,
3228 bfd_byte
*, bfd_byte
*, bfd_vma
, rsrc_entry
*);
3231 rsrc_parse_entry (bfd
* abfd
,
3232 bfd_boolean is_name
,
3234 bfd_byte
* datastart
,
3238 rsrc_directory
* parent
)
3240 unsigned long val
, addr
, size
;
3242 val
= bfd_get_32 (abfd
, data
);
3244 entry
->parent
= parent
;
3245 entry
->is_name
= is_name
;
3251 if (HighBitSet (val
))
3253 val
= WithoutHighBit (val
);
3255 address
= datastart
+ val
;
3259 address
= datastart
+ val
- rva_bias
;
3262 if (address
+ 3 > dataend
)
3265 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, address
);
3266 entry
->name_id
.name
.string
= address
+ 2;
3269 entry
->name_id
.id
= val
;
3271 val
= bfd_get_32 (abfd
, data
+ 4);
3273 if (HighBitSet (val
))
3275 entry
->is_dir
= TRUE
;
3276 entry
->value
.directory
= bfd_malloc (sizeof * entry
->value
.directory
);
3277 if (entry
->value
.directory
== NULL
)
3280 return rsrc_parse_directory (abfd
, entry
->value
.directory
,
3282 datastart
+ WithoutHighBit (val
),
3283 dataend
, rva_bias
, entry
);
3286 entry
->is_dir
= FALSE
;
3287 entry
->value
.leaf
= bfd_malloc (sizeof * entry
->value
.leaf
);
3288 if (entry
->value
.leaf
== NULL
)
3291 data
= datastart
+ val
;
3292 if (data
< datastart
|| data
>= dataend
)
3295 addr
= bfd_get_32 (abfd
, data
);
3296 size
= entry
->value
.leaf
->size
= bfd_get_32 (abfd
, data
+ 4);
3297 entry
->value
.leaf
->codepage
= bfd_get_32 (abfd
, data
+ 8);
3298 /* FIXME: We assume that the reserved field (data + 12) is OK. */
3300 entry
->value
.leaf
->data
= bfd_malloc (size
);
3301 if (entry
->value
.leaf
->data
== NULL
)
3304 memcpy (entry
->value
.leaf
->data
, datastart
+ addr
- rva_bias
, size
);
3305 return datastart
+ (addr
- rva_bias
) + size
;
3309 rsrc_parse_entries (bfd
* abfd
,
3310 rsrc_dir_chain
* chain
,
3311 bfd_boolean is_name
,
3312 bfd_byte
* highest_data
,
3313 bfd_byte
* datastart
,
3317 rsrc_directory
* parent
)
3322 if (chain
->num_entries
== 0)
3324 chain
->first_entry
= chain
->last_entry
= NULL
;
3325 return highest_data
;
3328 entry
= bfd_malloc (sizeof * entry
);
3332 chain
->first_entry
= entry
;
3334 for (i
= chain
->num_entries
; i
--;)
3336 bfd_byte
* entry_end
;
3338 entry_end
= rsrc_parse_entry (abfd
, is_name
, entry
, datastart
,
3339 data
, dataend
, rva_bias
, parent
);
3341 highest_data
= max (entry_end
, highest_data
);
3342 if (entry_end
> dataend
)
3347 entry
->next_entry
= bfd_malloc (sizeof * entry
);
3348 entry
= entry
->next_entry
;
3353 entry
->next_entry
= NULL
;
3356 chain
->last_entry
= entry
;
3358 return highest_data
;
3362 rsrc_parse_directory (bfd
* abfd
,
3363 rsrc_directory
* table
,
3364 bfd_byte
* datastart
,
3370 bfd_byte
* highest_data
= data
;
3375 table
->characteristics
= bfd_get_32 (abfd
, data
);
3376 table
->time
= bfd_get_32 (abfd
, data
+ 4);
3377 table
->major
= bfd_get_16 (abfd
, data
+ 8);
3378 table
->minor
= bfd_get_16 (abfd
, data
+ 10);
3379 table
->names
.num_entries
= bfd_get_16 (abfd
, data
+ 12);
3380 table
->ids
.num_entries
= bfd_get_16 (abfd
, data
+ 14);
3381 table
->entry
= entry
;
3385 highest_data
= rsrc_parse_entries (abfd
, & table
->names
, TRUE
, data
,
3386 datastart
, data
, dataend
, rva_bias
, table
);
3387 data
+= table
->names
.num_entries
* 8;
3389 highest_data
= rsrc_parse_entries (abfd
, & table
->ids
, FALSE
, highest_data
,
3390 datastart
, data
, dataend
, rva_bias
, table
);
3391 data
+= table
->ids
.num_entries
* 8;
3393 return max (highest_data
, data
);
3396 typedef struct rsrc_write_data
3399 bfd_byte
* datastart
;
3400 bfd_byte
* next_table
;
3401 bfd_byte
* next_leaf
;
3402 bfd_byte
* next_string
;
3403 bfd_byte
* next_data
;
3408 rsrc_write_string (rsrc_write_data
* data
,
3409 rsrc_string
* string
)
3411 bfd_put_16 (data
->abfd
, string
->len
, data
->next_string
);
3412 memcpy (data
->next_string
+ 2, string
->string
, string
->len
* 2);
3413 data
->next_string
+= (string
->len
+ 1) * 2;
3416 static inline unsigned int
3417 rsrc_compute_rva (rsrc_write_data
* data
,
3420 return (addr
- data
->datastart
) + data
->rva_bias
;
3424 rsrc_write_leaf (rsrc_write_data
* data
,
3427 bfd_put_32 (data
->abfd
, rsrc_compute_rva (data
, data
->next_data
),
3429 bfd_put_32 (data
->abfd
, leaf
->size
, data
->next_leaf
+ 4);
3430 bfd_put_32 (data
->abfd
, leaf
->codepage
, data
->next_leaf
+ 8);
3431 bfd_put_32 (data
->abfd
, 0 /*reserved*/, data
->next_leaf
+ 12);
3432 data
->next_leaf
+= 16;
3434 memcpy (data
->next_data
, leaf
->data
, leaf
->size
);
3435 /* An undocumented feature of Windows resources is that each unit
3436 of raw data is 8-byte aligned... */
3437 data
->next_data
+= ((leaf
->size
+ 7) & ~7);
3440 static void rsrc_write_directory (rsrc_write_data
*, rsrc_directory
*);
3443 rsrc_write_entry (rsrc_write_data
* data
,
3449 bfd_put_32 (data
->abfd
,
3450 SetHighBit (data
->next_string
- data
->datastart
),
3452 rsrc_write_string (data
, & entry
->name_id
.name
);
3455 bfd_put_32 (data
->abfd
, entry
->name_id
.id
, where
);
3459 bfd_put_32 (data
->abfd
,
3460 SetHighBit (data
->next_table
- data
->datastart
),
3462 rsrc_write_directory (data
, entry
->value
.directory
);
3466 bfd_put_32 (data
->abfd
, data
->next_leaf
- data
->datastart
, where
+ 4);
3467 rsrc_write_leaf (data
, entry
->value
.leaf
);
3472 rsrc_compute_region_sizes (rsrc_directory
* dir
)
3474 struct rsrc_entry
* entry
;
3479 sizeof_tables_and_entries
+= 16;
3481 for (entry
= dir
->names
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3483 sizeof_tables_and_entries
+= 8;
3485 sizeof_strings
+= (entry
->name_id
.name
.len
+ 1) * 2;
3488 rsrc_compute_region_sizes (entry
->value
.directory
);
3490 sizeof_leaves
+= 16;
3493 for (entry
= dir
->ids
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3495 sizeof_tables_and_entries
+= 8;
3498 rsrc_compute_region_sizes (entry
->value
.directory
);
3500 sizeof_leaves
+= 16;
3505 rsrc_write_directory (rsrc_write_data
* data
,
3506 rsrc_directory
* dir
)
3510 bfd_byte
* next_entry
;
3513 bfd_put_32 (data
->abfd
, dir
->characteristics
, data
->next_table
);
3514 bfd_put_32 (data
->abfd
, 0 /*dir->time*/, data
->next_table
+ 4);
3515 bfd_put_16 (data
->abfd
, dir
->major
, data
->next_table
+ 8);
3516 bfd_put_16 (data
->abfd
, dir
->minor
, data
->next_table
+ 10);
3517 bfd_put_16 (data
->abfd
, dir
->names
.num_entries
, data
->next_table
+ 12);
3518 bfd_put_16 (data
->abfd
, dir
->ids
.num_entries
, data
->next_table
+ 14);
3520 /* Compute where the entries and the next table will be placed. */
3521 next_entry
= data
->next_table
+ 16;
3522 data
->next_table
= next_entry
+ (dir
->names
.num_entries
* 8)
3523 + (dir
->ids
.num_entries
* 8);
3524 nt
= data
->next_table
;
3526 /* Write the entries. */
3527 for (i
= dir
->names
.num_entries
, entry
= dir
->names
.first_entry
;
3528 i
> 0 && entry
!= NULL
;
3529 i
--, entry
= entry
->next_entry
)
3531 BFD_ASSERT (entry
->is_name
);
3532 rsrc_write_entry (data
, next_entry
, entry
);
3535 BFD_ASSERT (i
== 0);
3536 BFD_ASSERT (entry
== NULL
);
3538 for (i
= dir
->ids
.num_entries
, entry
= dir
->ids
.first_entry
;
3539 i
> 0 && entry
!= NULL
;
3540 i
--, entry
= entry
->next_entry
)
3542 BFD_ASSERT (! entry
->is_name
);
3543 rsrc_write_entry (data
, next_entry
, entry
);
3546 BFD_ASSERT (i
== 0);
3547 BFD_ASSERT (entry
== NULL
);
3548 BFD_ASSERT (nt
== next_entry
);
3551 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3552 /* Return the length (number of units) of the first character in S,
3553 putting its 'ucs4_t' representation in *PUC. */
3556 #if defined HAVE_WCTYPE_H
3557 u16_mbtouc (wint_t * puc
, const unsigned short * s
, unsigned int n
)
3559 u16_mbtouc (wchar_t * puc
, const unsigned short * s
, unsigned int n
)
3562 unsigned short c
= * s
;
3564 if (c
< 0xd800 || c
>= 0xe000)
3574 if (s
[1] >= 0xdc00 && s
[1] < 0xe000)
3576 *puc
= 0x10000 + ((c
- 0xd800) << 10) + (s
[1] - 0xdc00);
3582 /* Incomplete multibyte character. */
3588 /* Invalid multibyte character. */
3592 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3594 /* Perform a comparison of two entries. */
3596 rsrc_cmp (bfd_boolean is_name
, rsrc_entry
* a
, rsrc_entry
* b
)
3605 return a
->name_id
.id
- b
->name_id
.id
;
3607 /* We have to perform a case insenstive, unicode string comparison... */
3608 astring
= a
->name_id
.name
.string
;
3609 alen
= a
->name_id
.name
.len
;
3610 bstring
= b
->name_id
.name
.string
;
3611 blen
= b
->name_id
.name
.len
;
3613 #if defined __CYGWIN__ || defined __MINGW32__
3614 /* Under Windows hosts (both Cygwin and Mingw types),
3615 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3616 function however goes by different names in the two environments... */
3620 #define rscpcmp wcsncasecmp
3623 #define rscpcmp wcsnicmp
3626 res
= rscpcmp ((const wchar_t *) astring
, (const wchar_t *) bstring
,
3629 #elif defined HAVE_WCHAR_H
3634 for (i
= min (alen
, blen
); i
--; astring
+= 2, bstring
+= 2)
3636 #if defined HAVE_WCTYPE_H
3644 /* Convert UTF-16 unicode characters into wchar_t characters
3645 so that we can then perform a case insensitive comparison. */
3646 unsigned int Alen
= u16_mbtouc (& awc
, (const unsigned short *) astring
, 2);
3647 unsigned int Blen
= u16_mbtouc (& bwc
, (const unsigned short *) bstring
, 2);
3652 #ifdef HAVE_WCTYPE_H
3653 awc
= towlower (awc
);
3654 bwc
= towlower (bwc
);
3658 res
= wcsncasecmp (& awc
, & bwc
, 1);
3665 /* Do the best we can - a case sensitive, untranslated comparison. */
3666 res
= memcmp (astring
, bstring
, min (alen
, blen
) * 2);
3676 rsrc_print_name (char * buffer
, rsrc_string string
)
3679 bfd_byte
* name
= string
.string
;
3681 for (i
= string
.len
; i
--; name
+= 2)
3682 sprintf (buffer
+ strlen (buffer
), "%.1s", name
);
3686 rsrc_resource_name (rsrc_entry
*entry
, rsrc_directory
*dir
, char *buffer
)
3688 bfd_boolean is_string
= FALSE
;
3692 if (dir
!= NULL
&& dir
->entry
!= NULL
&& dir
->entry
->parent
!= NULL
3693 && dir
->entry
->parent
->entry
!= NULL
)
3695 strcpy (buffer
, "type: ");
3696 if (dir
->entry
->parent
->entry
->is_name
)
3697 rsrc_print_name (buffer
+ strlen (buffer
),
3698 dir
->entry
->parent
->entry
->name_id
.name
);
3701 unsigned int id
= dir
->entry
->parent
->entry
->name_id
.id
;
3703 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3706 case 1: strcat (buffer
, " (CURSOR)"); break;
3707 case 2: strcat (buffer
, " (BITMAP)"); break;
3708 case 3: strcat (buffer
, " (ICON)"); break;
3709 case 4: strcat (buffer
, " (MENU)"); break;
3710 case 5: strcat (buffer
, " (DIALOG)"); break;
3711 case 6: strcat (buffer
, " (STRING)"); is_string
= TRUE
; break;
3712 case 7: strcat (buffer
, " (FONTDIR)"); break;
3713 case 8: strcat (buffer
, " (FONT)"); break;
3714 case 9: strcat (buffer
, " (ACCELERATOR)"); break;
3715 case 10: strcat (buffer
, " (RCDATA)"); break;
3716 case 11: strcat (buffer
, " (MESSAGETABLE)"); break;
3717 case 12: strcat (buffer
, " (GROUP_CURSOR)"); break;
3718 case 14: strcat (buffer
, " (GROUP_ICON)"); break;
3719 case 16: strcat (buffer
, " (VERSION)"); break;
3720 case 17: strcat (buffer
, " (DLGINCLUDE)"); break;
3721 case 19: strcat (buffer
, " (PLUGPLAY)"); break;
3722 case 20: strcat (buffer
, " (VXD)"); break;
3723 case 21: strcat (buffer
, " (ANICURSOR)"); break;
3724 case 22: strcat (buffer
, " (ANIICON)"); break;
3725 case 23: strcat (buffer
, " (HTML)"); break;
3726 case 24: strcat (buffer
, " (MANIFEST)"); break;
3727 case 240: strcat (buffer
, " (DLGINIT)"); break;
3728 case 241: strcat (buffer
, " (TOOLBAR)"); break;
3733 if (dir
!= NULL
&& dir
->entry
!= NULL
)
3735 strcat (buffer
, " name: ");
3736 if (dir
->entry
->is_name
)
3737 rsrc_print_name (buffer
+ strlen (buffer
), dir
->entry
->name_id
.name
);
3740 unsigned int id
= dir
->entry
->name_id
.id
;
3742 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3745 sprintf (buffer
+ strlen (buffer
), " (resource id range: %d - %d)",
3746 (id
- 1) << 4, (id
<< 4) - 1);
3752 strcat (buffer
, " lang: ");
3755 rsrc_print_name (buffer
+ strlen (buffer
), entry
->name_id
.name
);
3757 sprintf (buffer
+ strlen (buffer
), "%x", entry
->name_id
.id
);
3763 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3764 their ID is stored in the NAME entry. The bottom four bits are used as
3765 an index into unicode string table that makes up the data of the leaf.
3766 So identical type-name-lang string resources may not actually be
3769 This function is called when we have detected two string resources with
3770 match top-28-bit IDs. We have to scan the string tables inside the leaves
3771 and discover if there are any real collisions. If there are then we report
3772 them and return FALSE. Otherwise we copy any strings from B into A and
3773 then return TRUE. */
3776 rsrc_merge_string_entries (rsrc_entry
* a ATTRIBUTE_UNUSED
,
3777 rsrc_entry
* b ATTRIBUTE_UNUSED
)
3779 unsigned int copy_needed
= 0;
3783 bfd_byte
* new_data
;
3786 /* Step one: Find out what we have to do. */
3787 BFD_ASSERT (! a
->is_dir
);
3788 astring
= a
->value
.leaf
->data
;
3790 BFD_ASSERT (! b
->is_dir
);
3791 bstring
= b
->value
.leaf
->data
;
3793 for (i
= 0; i
< 16; i
++)
3795 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3796 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3800 copy_needed
+= blen
* 2;
3804 else if (alen
!= blen
)
3805 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3807 /* alen == blen != 0. We might have two identical strings. If so we
3808 can ignore the second one. There is no need for wchar_t vs UTF-16
3809 theatrics here - we are only interested in (case sensitive) equality. */
3810 else if (memcmp (astring
+ 2, bstring
+ 2, alen
* 2) != 0)
3813 astring
+= (alen
+ 1) * 2;
3814 bstring
+= (blen
+ 1) * 2;
3819 if (a
->parent
!= NULL
3820 && a
->parent
->entry
!= NULL
3821 && !a
->parent
->entry
->is_name
)
3822 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3823 ((a
->parent
->entry
->name_id
.id
- 1) << 4) + i
);
3827 if (copy_needed
== 0)
3830 /* If we reach here then A and B must both have non-colliding strings.
3831 (We never get string resources with fully empty string tables).
3832 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3834 new_data
= bfd_malloc (a
->value
.leaf
->size
+ copy_needed
);
3835 if (new_data
== NULL
)
3839 astring
= a
->value
.leaf
->data
;
3840 bstring
= b
->value
.leaf
->data
;
3842 for (i
= 0; i
< 16; i
++)
3844 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3845 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3849 memcpy (nstring
, astring
, (alen
+ 1) * 2);
3850 nstring
+= (alen
+ 1) * 2;
3854 memcpy (nstring
, bstring
, (blen
+ 1) * 2);
3855 nstring
+= (blen
+ 1) * 2;
3863 astring
+= (alen
+ 1) * 2;
3864 bstring
+= (blen
+ 1) * 2;
3867 BFD_ASSERT (nstring
- new_data
== (signed) (a
->value
.leaf
->size
+ copy_needed
));
3869 free (a
->value
.leaf
->data
);
3870 a
->value
.leaf
->data
= new_data
;
3871 a
->value
.leaf
->size
+= copy_needed
;
3876 static void rsrc_merge (rsrc_entry
*, rsrc_entry
*);
3878 /* Sort the entries in given part of the directory.
3879 We use an old fashioned bubble sort because we are dealing
3880 with lists and we want to handle matches specially. */
3883 rsrc_sort_entries (rsrc_dir_chain
* chain
,
3884 bfd_boolean is_name
,
3885 rsrc_directory
* dir
)
3889 rsrc_entry
** points_to_entry
;
3890 bfd_boolean swapped
;
3892 if (chain
->num_entries
< 2)
3898 points_to_entry
= & chain
->first_entry
;
3899 entry
= * points_to_entry
;
3900 next
= entry
->next_entry
;
3904 signed int cmp
= rsrc_cmp (is_name
, entry
, next
);
3908 entry
->next_entry
= next
->next_entry
;
3909 next
->next_entry
= entry
;
3910 * points_to_entry
= next
;
3911 points_to_entry
= & next
->next_entry
;
3912 next
= entry
->next_entry
;
3917 if (entry
->is_dir
&& next
->is_dir
)
3919 /* When we encounter identical directory entries we have to
3920 merge them together. The exception to this rule is for
3921 resource manifests - there can only be one of these,
3922 even if they differ in language. Zero-language manifests
3923 are assumed to be default manifests (provided by the
3924 Cygwin/MinGW build system) and these can be silently dropped,
3925 unless that would reduce the number of manifests to zero.
3926 There should only ever be one non-zero lang manifest -
3927 if there are more it is an error. A non-zero lang
3928 manifest takes precedence over a default manifest. */
3930 && entry
->name_id
.id
== 1
3932 && dir
->entry
!= NULL
3933 && !dir
->entry
->is_name
3934 && dir
->entry
->name_id
.id
== 0x18)
3936 if (next
->value
.directory
->names
.num_entries
== 0
3937 && next
->value
.directory
->ids
.num_entries
== 1
3938 && !next
->value
.directory
->ids
.first_entry
->is_name
3939 && next
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3940 /* Fall through so that NEXT is dropped. */
3942 else if (entry
->value
.directory
->names
.num_entries
== 0
3943 && entry
->value
.directory
->ids
.num_entries
== 1
3944 && !entry
->value
.directory
->ids
.first_entry
->is_name
3945 && entry
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3947 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
3948 entry
->next_entry
= next
->next_entry
;
3949 next
->next_entry
= entry
;
3950 * points_to_entry
= next
;
3951 points_to_entry
= & next
->next_entry
;
3952 next
= entry
->next_entry
;
3957 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3958 bfd_set_error (bfd_error_file_truncated
);
3962 /* Unhook NEXT from the chain. */
3963 /* FIXME: memory loss here. */
3964 entry
->next_entry
= next
->next_entry
;
3965 chain
->num_entries
--;
3966 if (chain
->num_entries
< 2)
3968 next
= next
->next_entry
;
3971 rsrc_merge (entry
, next
);
3973 else if (entry
->is_dir
!= next
->is_dir
)
3975 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
3976 bfd_set_error (bfd_error_file_truncated
);
3981 /* Otherwise with identical leaves we issue an error
3982 message - because there should never be duplicates.
3983 The exception is Type 18/Name 1/Lang 0 which is the
3984 defaul manifest - this can just be dropped. */
3986 && entry
->name_id
.id
== 0
3988 && dir
->entry
!= NULL
3989 && !dir
->entry
->is_name
3990 && dir
->entry
->name_id
.id
== 1
3991 && dir
->entry
->parent
!= NULL
3992 && dir
->entry
->parent
->entry
!= NULL
3993 && !dir
->entry
->parent
->entry
->is_name
3994 && dir
->entry
->parent
->entry
->name_id
.id
== 0x18 /* RT_MANIFEST */)
3996 else if (dir
!= NULL
3997 && dir
->entry
!= NULL
3998 && dir
->entry
->parent
!= NULL
3999 && dir
->entry
->parent
->entry
!= NULL
4000 && !dir
->entry
->parent
->entry
->is_name
4001 && dir
->entry
->parent
->entry
->name_id
.id
== 0x6 /* RT_STRING */)
4003 /* Strings need special handling. */
4004 if (! rsrc_merge_string_entries (entry
, next
))
4006 /* _bfd_error_handler should have been called inside merge_strings. */
4007 bfd_set_error (bfd_error_file_truncated
);
4014 || dir
->entry
== NULL
4015 || dir
->entry
->parent
== NULL
4016 || dir
->entry
->parent
->entry
== NULL
)
4017 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
4022 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
4023 rsrc_resource_name (entry
, dir
, buff
));
4025 bfd_set_error (bfd_error_file_truncated
);
4030 /* Unhook NEXT from the chain. */
4031 entry
->next_entry
= next
->next_entry
;
4032 chain
->num_entries
--;
4033 if (chain
->num_entries
< 2)
4035 next
= next
->next_entry
;
4039 points_to_entry
= & entry
->next_entry
;
4041 next
= next
->next_entry
;
4046 chain
->last_entry
= entry
;
4051 /* Attach B's chain onto A. */
4053 rsrc_attach_chain (rsrc_dir_chain
* achain
, rsrc_dir_chain
* bchain
)
4055 if (bchain
->num_entries
== 0)
4058 achain
->num_entries
+= bchain
->num_entries
;
4060 if (achain
->first_entry
== NULL
)
4062 achain
->first_entry
= bchain
->first_entry
;
4063 achain
->last_entry
= bchain
->last_entry
;
4067 achain
->last_entry
->next_entry
= bchain
->first_entry
;
4068 achain
->last_entry
= bchain
->last_entry
;
4071 bchain
->num_entries
= 0;
4072 bchain
->first_entry
= bchain
->last_entry
= NULL
;
4076 rsrc_merge (struct rsrc_entry
* a
, struct rsrc_entry
* b
)
4078 rsrc_directory
* adir
;
4079 rsrc_directory
* bdir
;
4081 BFD_ASSERT (a
->is_dir
);
4082 BFD_ASSERT (b
->is_dir
);
4084 adir
= a
->value
.directory
;
4085 bdir
= b
->value
.directory
;
4087 if (adir
->characteristics
!= bdir
->characteristics
)
4089 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics"));
4090 bfd_set_error (bfd_error_file_truncated
);
4094 if (adir
->major
!= bdir
->major
|| adir
->minor
!= bdir
->minor
)
4096 _bfd_error_handler (_(".rsrc merge failure: differing directory versions"));
4097 bfd_set_error (bfd_error_file_truncated
);
4101 /* Attach B's name chain to A. */
4102 rsrc_attach_chain (& adir
->names
, & bdir
->names
);
4104 /* Attach B's ID chain to A. */
4105 rsrc_attach_chain (& adir
->ids
, & bdir
->ids
);
4107 /* Now sort A's entries. */
4108 rsrc_sort_entries (& adir
->names
, TRUE
, adir
);
4109 rsrc_sort_entries (& adir
->ids
, FALSE
, adir
);
4112 /* Check the .rsrc section. If it contains multiple concatenated
4113 resources then we must merge them properly. Otherwise Windows
4114 will ignore all but the first set. */
4117 rsrc_process_section (bfd
* abfd
,
4118 struct coff_final_link_info
* pfinfo
)
4120 rsrc_directory new_table
;
4126 bfd_byte
* datastart
;
4128 bfd_byte
* new_data
;
4129 unsigned int num_resource_sets
;
4130 rsrc_directory
* type_tables
;
4131 rsrc_write_data write_data
;
4134 unsigned int num_input_rsrc
= 0;
4135 unsigned int max_num_input_rsrc
= 4;
4136 ptrdiff_t * rsrc_sizes
= NULL
;
4138 new_table
.names
.num_entries
= 0;
4139 new_table
.ids
.num_entries
= 0;
4141 sec
= bfd_get_section_by_name (abfd
, ".rsrc");
4142 if (sec
== NULL
|| (size
= sec
->rawsize
) == 0)
4145 pe
= pe_data (abfd
);
4149 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4151 data
= bfd_malloc (size
);
4157 if (! bfd_get_section_contents (abfd
, sec
, data
, 0, size
))
4160 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4161 their lengths. Note - we rely upon the fact that the linker script
4162 does *not* sort the input .rsrc sections, so that the order in the
4163 linkinfo list matches the order in the output .rsrc section.
4165 We need to know the lengths because each input .rsrc section has padding
4166 at the end of a variable amount. (It does not appear to be based upon
4167 the section alignment or the file alignment). We need to skip any
4168 padding bytes when parsing the input .rsrc sections. */
4169 rsrc_sizes
= bfd_malloc (max_num_input_rsrc
* sizeof * rsrc_sizes
);
4170 if (rsrc_sizes
== NULL
)
4173 for (input
= pfinfo
->info
->input_bfds
;
4175 input
= input
->link
.next
)
4177 asection
* rsrc_sec
= bfd_get_section_by_name (input
, ".rsrc");
4179 /* PR 18372 - skip discarded .rsrc sections. */
4180 if (rsrc_sec
!= NULL
&& !discarded_section (rsrc_sec
))
4182 if (num_input_rsrc
== max_num_input_rsrc
)
4184 max_num_input_rsrc
+= 10;
4185 rsrc_sizes
= bfd_realloc (rsrc_sizes
, max_num_input_rsrc
4186 * sizeof * rsrc_sizes
);
4187 if (rsrc_sizes
== NULL
)
4191 BFD_ASSERT (rsrc_sec
->size
> 0);
4192 rsrc_sizes
[num_input_rsrc
++] = rsrc_sec
->size
;
4196 if (num_input_rsrc
< 2)
4199 /* Step one: Walk the section, computing the size of the tables,
4200 leaves and data and decide if we need to do anything. */
4201 dataend
= data
+ size
;
4202 num_resource_sets
= 0;
4204 while (data
< dataend
)
4206 bfd_byte
* p
= data
;
4208 data
= rsrc_count_directory (abfd
, data
, data
, dataend
, rva_bias
);
4212 /* Corrupted .rsrc section - cannot merge. */
4213 _bfd_error_handler (_("%pB: .rsrc merge failure: corrupt .rsrc section"),
4215 bfd_set_error (bfd_error_file_truncated
);
4219 if ((data
- p
) > rsrc_sizes
[num_resource_sets
])
4221 _bfd_error_handler (_("%pB: .rsrc merge failure: unexpected .rsrc size"),
4223 bfd_set_error (bfd_error_file_truncated
);
4226 /* FIXME: Should we add a check for "data - p" being much smaller
4227 than rsrc_sizes[num_resource_sets] ? */
4229 data
= p
+ rsrc_sizes
[num_resource_sets
];
4230 rva_bias
+= data
- p
;
4231 ++ num_resource_sets
;
4233 BFD_ASSERT (num_resource_sets
== num_input_rsrc
);
4235 /* Step two: Walk the data again, building trees of the resources. */
4237 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4239 type_tables
= bfd_malloc (num_resource_sets
* sizeof * type_tables
);
4240 if (type_tables
== NULL
)
4244 while (data
< dataend
)
4246 bfd_byte
* p
= data
;
4248 (void) rsrc_parse_directory (abfd
, type_tables
+ indx
, data
, data
,
4249 dataend
, rva_bias
, NULL
);
4250 data
= p
+ rsrc_sizes
[indx
];
4251 rva_bias
+= data
- p
;
4254 BFD_ASSERT (indx
== num_resource_sets
);
4256 /* Step three: Merge the top level tables (there can be only one).
4258 We must ensure that the merged entries are in ascending order.
4260 We also thread the top level table entries from the old tree onto
4261 the new table, so that they can be pulled off later. */
4263 /* FIXME: Should we verify that all type tables are the same ? */
4264 new_table
.characteristics
= type_tables
[0].characteristics
;
4265 new_table
.time
= type_tables
[0].time
;
4266 new_table
.major
= type_tables
[0].major
;
4267 new_table
.minor
= type_tables
[0].minor
;
4269 /* Chain the NAME entries onto the table. */
4270 new_table
.names
.first_entry
= NULL
;
4271 new_table
.names
.last_entry
= NULL
;
4273 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4274 rsrc_attach_chain (& new_table
.names
, & type_tables
[indx
].names
);
4276 rsrc_sort_entries (& new_table
.names
, TRUE
, & new_table
);
4278 /* Chain the ID entries onto the table. */
4279 new_table
.ids
.first_entry
= NULL
;
4280 new_table
.ids
.last_entry
= NULL
;
4282 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4283 rsrc_attach_chain (& new_table
.ids
, & type_tables
[indx
].ids
);
4285 rsrc_sort_entries (& new_table
.ids
, FALSE
, & new_table
);
4287 /* Step four: Create new contents for the .rsrc section. */
4288 /* Step four point one: Compute the size of each region of the .rsrc section.
4289 We do this now, rather than earlier, as the merging above may have dropped
4291 sizeof_leaves
= sizeof_strings
= sizeof_tables_and_entries
= 0;
4292 rsrc_compute_region_sizes (& new_table
);
4293 /* We increment sizeof_strings to make sure that resource data
4294 starts on an 8-byte boundary. FIXME: Is this correct ? */
4295 sizeof_strings
= (sizeof_strings
+ 7) & ~ 7;
4297 new_data
= bfd_zalloc (abfd
, size
);
4298 if (new_data
== NULL
)
4301 write_data
.abfd
= abfd
;
4302 write_data
.datastart
= new_data
;
4303 write_data
.next_table
= new_data
;
4304 write_data
.next_leaf
= new_data
+ sizeof_tables_and_entries
;
4305 write_data
.next_string
= write_data
.next_leaf
+ sizeof_leaves
;
4306 write_data
.next_data
= write_data
.next_string
+ sizeof_strings
;
4307 write_data
.rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4309 rsrc_write_directory (& write_data
, & new_table
);
4311 /* Step five: Replace the old contents with the new.
4312 We don't recompute the size as it's too late here to shrink section.
4313 See PR ld/20193 for more details. */
4314 bfd_set_section_contents (pfinfo
->output_bfd
, sec
, new_data
, 0, size
);
4315 sec
->size
= sec
->rawsize
= size
;
4318 /* Step six: Free all the memory that we have used. */
4319 /* FIXME: Free the resource tree, if we have one. */
4324 /* Handle the .idata section and other things that need symbol table
4328 _bfd_XXi_final_link_postscript (bfd
* abfd
, struct coff_final_link_info
*pfinfo
)
4330 struct coff_link_hash_entry
*h1
;
4331 struct bfd_link_info
*info
= pfinfo
->info
;
4332 bfd_boolean result
= TRUE
;
4334 /* There are a few fields that need to be filled in now while we
4335 have symbol table access.
4337 The .idata subsections aren't directly available as sections, but
4338 they are in the symbol table, so get them from there. */
4340 /* The import directory. This is the address of .idata$2, with size
4341 of .idata$2 + .idata$3. */
4342 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4343 ".idata$2", FALSE
, FALSE
, TRUE
);
4346 /* PR ld/2729: We cannot rely upon all the output sections having been
4347 created properly, so check before referencing them. Issue a warning
4348 message for any sections tht could not be found. */
4349 if ((h1
->root
.type
== bfd_link_hash_defined
4350 || h1
->root
.type
== bfd_link_hash_defweak
)
4351 && h1
->root
.u
.def
.section
!= NULL
4352 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4353 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
=
4354 (h1
->root
.u
.def
.value
4355 + h1
->root
.u
.def
.section
->output_section
->vma
4356 + h1
->root
.u
.def
.section
->output_offset
);
4360 (_("%pB: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4365 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4366 ".idata$4", FALSE
, FALSE
, TRUE
);
4368 && (h1
->root
.type
== bfd_link_hash_defined
4369 || h1
->root
.type
== bfd_link_hash_defweak
)
4370 && h1
->root
.u
.def
.section
!= NULL
4371 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4372 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].Size
=
4373 ((h1
->root
.u
.def
.value
4374 + h1
->root
.u
.def
.section
->output_section
->vma
4375 + h1
->root
.u
.def
.section
->output_offset
)
4376 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
);
4380 (_("%pB: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4385 /* The import address table. This is the size/address of
4387 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4388 ".idata$5", FALSE
, FALSE
, TRUE
);
4390 && (h1
->root
.type
== bfd_link_hash_defined
4391 || h1
->root
.type
== bfd_link_hash_defweak
)
4392 && h1
->root
.u
.def
.section
!= NULL
4393 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4394 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4395 (h1
->root
.u
.def
.value
4396 + h1
->root
.u
.def
.section
->output_section
->vma
4397 + h1
->root
.u
.def
.section
->output_offset
);
4401 (_("%pB: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4406 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4407 ".idata$6", FALSE
, FALSE
, TRUE
);
4409 && (h1
->root
.type
== bfd_link_hash_defined
4410 || h1
->root
.type
== bfd_link_hash_defweak
)
4411 && h1
->root
.u
.def
.section
!= NULL
4412 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4413 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4414 ((h1
->root
.u
.def
.value
4415 + h1
->root
.u
.def
.section
->output_section
->vma
4416 + h1
->root
.u
.def
.section
->output_offset
)
4417 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
);
4421 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4428 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4429 "__IAT_start__", FALSE
, FALSE
, TRUE
);
4431 && (h1
->root
.type
== bfd_link_hash_defined
4432 || h1
->root
.type
== bfd_link_hash_defweak
)
4433 && h1
->root
.u
.def
.section
!= NULL
4434 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4439 (h1
->root
.u
.def
.value
4440 + h1
->root
.u
.def
.section
->output_section
->vma
4441 + h1
->root
.u
.def
.section
->output_offset
);
4443 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4444 "__IAT_end__", FALSE
, FALSE
, TRUE
);
4446 && (h1
->root
.type
== bfd_link_hash_defined
4447 || h1
->root
.type
== bfd_link_hash_defweak
)
4448 && h1
->root
.u
.def
.section
!= NULL
4449 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4451 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4452 ((h1
->root
.u
.def
.value
4453 + h1
->root
.u
.def
.section
->output_section
->vma
4454 + h1
->root
.u
.def
.section
->output_offset
)
4456 if (pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
!= 0)
4457 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4458 iat_va
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
4463 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4464 " because .idata$6 is missing"), abfd
);
4470 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4471 (bfd_get_symbol_leading_char (abfd
) != 0
4472 ? "__tls_used" : "_tls_used"),
4473 FALSE
, FALSE
, TRUE
);
4476 if ((h1
->root
.type
== bfd_link_hash_defined
4477 || h1
->root
.type
== bfd_link_hash_defweak
)
4478 && h1
->root
.u
.def
.section
!= NULL
4479 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4480 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].VirtualAddress
=
4481 (h1
->root
.u
.def
.value
4482 + h1
->root
.u
.def
.section
->output_section
->vma
4483 + h1
->root
.u
.def
.section
->output_offset
4484 - pe_data (abfd
)->pe_opthdr
.ImageBase
);
4488 (_("%pB: unable to fill in DataDictionary[9] because __tls_used is missing"),
4492 /* According to PECOFF sepcifications by Microsoft version 8.2
4493 the TLS data directory consists of 4 pointers, followed
4494 by two 4-byte integer. This implies that the total size
4495 is different for 32-bit and 64-bit executables. */
4496 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4497 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x18;
4499 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x28;
4503 /* If there is a .pdata section and we have linked pdata finally, we
4504 need to sort the entries ascending. */
4505 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4507 asection
*sec
= bfd_get_section_by_name (abfd
, ".pdata");
4511 bfd_size_type x
= sec
->rawsize
;
4512 bfd_byte
*tmp_data
= NULL
;
4515 tmp_data
= bfd_malloc (x
);
4517 if (tmp_data
!= NULL
)
4519 if (bfd_get_section_contents (abfd
, sec
, tmp_data
, 0, x
))
4523 12, sort_x64_pdata
);
4524 bfd_set_section_contents (pfinfo
->output_bfd
, sec
,
4535 rsrc_process_section (abfd
, pfinfo
);
4537 /* If we couldn't find idata$2, we either have an excessively
4538 trivial program or are in DEEP trouble; we have to assume trivial