1 /* Support for the generic parts of PE/PEI; the common executable parts.
2 Copyright (C) 1995-2020 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
, FILNMLEN
);
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 PUT_SCNHDR_VADDR (abfd
,
937 ((scnhdr_int
->s_vaddr
938 - pe_data (abfd
)->pe_opthdr
.ImageBase
)
940 scnhdr_ext
->s_vaddr
);
942 /* NT wants the size data to be rounded up to the next
943 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
945 if ((scnhdr_int
->s_flags
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
) != 0)
947 if (bfd_pei_p (abfd
))
949 ps
= scnhdr_int
->s_size
;
955 ss
= scnhdr_int
->s_size
;
960 if (bfd_pei_p (abfd
))
961 ps
= scnhdr_int
->s_paddr
;
965 ss
= scnhdr_int
->s_size
;
968 PUT_SCNHDR_SIZE (abfd
, ss
,
971 /* s_paddr in PE is really the virtual size. */
972 PUT_SCNHDR_PADDR (abfd
, ps
, scnhdr_ext
->s_paddr
);
974 PUT_SCNHDR_SCNPTR (abfd
, scnhdr_int
->s_scnptr
,
975 scnhdr_ext
->s_scnptr
);
976 PUT_SCNHDR_RELPTR (abfd
, scnhdr_int
->s_relptr
,
977 scnhdr_ext
->s_relptr
);
978 PUT_SCNHDR_LNNOPTR (abfd
, scnhdr_int
->s_lnnoptr
,
979 scnhdr_ext
->s_lnnoptr
);
982 /* Extra flags must be set when dealing with PE. All sections should also
983 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
984 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
985 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
986 (this is especially important when dealing with the .idata section since
987 the addresses for routines from .dlls must be overwritten). If .reloc
988 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
989 (0x02000000). Also, the resource data should also be read and
992 /* FIXME: Alignment is also encoded in this field, at least on
993 ARM-WINCE. Although - how do we get the original alignment field
998 char section_name
[SCNNMLEN
];
999 unsigned long must_have
;
1001 pe_required_section_flags
;
1003 pe_required_section_flags known_sections
[] =
1005 { ".arch", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
| IMAGE_SCN_ALIGN_8BYTES
},
1006 { ".bss", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1007 { ".data", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1008 { ".edata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1009 { ".idata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1010 { ".pdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1011 { ".rdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1012 { ".reloc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
},
1013 { ".rsrc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1014 { ".text" , IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_CODE
| IMAGE_SCN_MEM_EXECUTE
},
1015 { ".tls", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1016 { ".xdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1019 pe_required_section_flags
* p
;
1021 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1022 we know exactly what this specific section wants so we remove it
1023 and then allow the must_have field to add it back in if necessary.
1024 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1025 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
1026 by ld --enable-auto-import (if auto-import is actually needed),
1027 by ld --omagic, or by obcopy --writable-text. */
1029 for (p
= known_sections
;
1030 p
< known_sections
+ ARRAY_SIZE (known_sections
);
1032 if (memcmp (scnhdr_int
->s_name
, p
->section_name
, SCNNMLEN
) == 0)
1034 if (memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text")
1035 || (bfd_get_file_flags (abfd
) & WP_TEXT
))
1036 scnhdr_int
->s_flags
&= ~IMAGE_SCN_MEM_WRITE
;
1037 scnhdr_int
->s_flags
|= p
->must_have
;
1041 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1044 if (coff_data (abfd
)->link_info
1045 && ! bfd_link_relocatable (coff_data (abfd
)->link_info
)
1046 && ! bfd_link_pic (coff_data (abfd
)->link_info
)
1047 && memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text") == 0)
1049 /* By inference from looking at MS output, the 32 bit field
1050 which is the combination of the number_of_relocs and
1051 number_of_linenos is used for the line number count in
1052 executables. A 16-bit field won't do for cc1. The MS
1053 document says that the number of relocs is zero for
1054 executables, but the 17-th bit has been observed to be there.
1055 Overflow is not an issue: a 4G-line program will overflow a
1056 bunch of other fields long before this! */
1057 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
& 0xffff), scnhdr_ext
->s_nlnno
);
1058 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
>> 16), scnhdr_ext
->s_nreloc
);
1062 if (scnhdr_int
->s_nlnno
<= 0xffff)
1063 H_PUT_16 (abfd
, scnhdr_int
->s_nlnno
, scnhdr_ext
->s_nlnno
);
1066 /* xgettext:c-format */
1067 _bfd_error_handler (_("%pB: line number overflow: 0x%lx > 0xffff"),
1068 abfd
, scnhdr_int
->s_nlnno
);
1069 bfd_set_error (bfd_error_file_truncated
);
1070 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nlnno
);
1074 /* Although we could encode 0xffff relocs here, we do not, to be
1075 consistent with other parts of bfd. Also it lets us warn, as
1076 we should never see 0xffff here w/o having the overflow flag
1078 if (scnhdr_int
->s_nreloc
< 0xffff)
1079 H_PUT_16 (abfd
, scnhdr_int
->s_nreloc
, scnhdr_ext
->s_nreloc
);
1082 /* PE can deal with large #s of relocs, but not here. */
1083 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nreloc
);
1084 scnhdr_int
->s_flags
|= IMAGE_SCN_LNK_NRELOC_OVFL
;
1085 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1092 _bfd_XXi_swap_debugdir_in (bfd
* abfd
, void * ext1
, void * in1
)
1094 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) ext1
;
1095 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) in1
;
1097 in
->Characteristics
= H_GET_32(abfd
, ext
->Characteristics
);
1098 in
->TimeDateStamp
= H_GET_32(abfd
, ext
->TimeDateStamp
);
1099 in
->MajorVersion
= H_GET_16(abfd
, ext
->MajorVersion
);
1100 in
->MinorVersion
= H_GET_16(abfd
, ext
->MinorVersion
);
1101 in
->Type
= H_GET_32(abfd
, ext
->Type
);
1102 in
->SizeOfData
= H_GET_32(abfd
, ext
->SizeOfData
);
1103 in
->AddressOfRawData
= H_GET_32(abfd
, ext
->AddressOfRawData
);
1104 in
->PointerToRawData
= H_GET_32(abfd
, ext
->PointerToRawData
);
1108 _bfd_XXi_swap_debugdir_out (bfd
* abfd
, void * inp
, void * extp
)
1110 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) extp
;
1111 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) inp
;
1113 H_PUT_32(abfd
, in
->Characteristics
, ext
->Characteristics
);
1114 H_PUT_32(abfd
, in
->TimeDateStamp
, ext
->TimeDateStamp
);
1115 H_PUT_16(abfd
, in
->MajorVersion
, ext
->MajorVersion
);
1116 H_PUT_16(abfd
, in
->MinorVersion
, ext
->MinorVersion
);
1117 H_PUT_32(abfd
, in
->Type
, ext
->Type
);
1118 H_PUT_32(abfd
, in
->SizeOfData
, ext
->SizeOfData
);
1119 H_PUT_32(abfd
, in
->AddressOfRawData
, ext
->AddressOfRawData
);
1120 H_PUT_32(abfd
, in
->PointerToRawData
, ext
->PointerToRawData
);
1122 return sizeof (struct external_IMAGE_DEBUG_DIRECTORY
);
1126 _bfd_XXi_slurp_codeview_record (bfd
* abfd
, file_ptr where
, unsigned long length
, CODEVIEW_INFO
*cvinfo
)
1129 bfd_size_type nread
;
1131 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1134 if (length
<= sizeof (CV_INFO_PDB70
) && length
<= sizeof (CV_INFO_PDB20
))
1138 nread
= bfd_bread (buffer
, length
, abfd
);
1139 if (length
!= nread
)
1142 /* Ensure null termination of filename. */
1143 memset (buffer
+ nread
, 0, sizeof (buffer
) - nread
);
1145 cvinfo
->CVSignature
= H_GET_32 (abfd
, buffer
);
1148 if ((cvinfo
->CVSignature
== CVINFO_PDB70_CVSIGNATURE
)
1149 && (length
> sizeof (CV_INFO_PDB70
)))
1151 CV_INFO_PDB70
*cvinfo70
= (CV_INFO_PDB70
*)(buffer
);
1153 cvinfo
->Age
= H_GET_32(abfd
, cvinfo70
->Age
);
1155 /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1156 by 8 single bytes. Byte swap them so we can conveniently treat the GUID
1157 as 16 bytes in big-endian order. */
1158 bfd_putb32 (bfd_getl32 (cvinfo70
->Signature
), cvinfo
->Signature
);
1159 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[4])), &(cvinfo
->Signature
[4]));
1160 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[6])), &(cvinfo
->Signature
[6]));
1161 memcpy (&(cvinfo
->Signature
[8]), &(cvinfo70
->Signature
[8]), 8);
1163 cvinfo
->SignatureLength
= CV_INFO_SIGNATURE_LENGTH
;
1164 /* cvinfo->PdbFileName = cvinfo70->PdbFileName; */
1168 else if ((cvinfo
->CVSignature
== CVINFO_PDB20_CVSIGNATURE
)
1169 && (length
> sizeof (CV_INFO_PDB20
)))
1171 CV_INFO_PDB20
*cvinfo20
= (CV_INFO_PDB20
*)(buffer
);
1172 cvinfo
->Age
= H_GET_32(abfd
, cvinfo20
->Age
);
1173 memcpy (cvinfo
->Signature
, cvinfo20
->Signature
, 4);
1174 cvinfo
->SignatureLength
= 4;
1175 /* cvinfo->PdbFileName = cvinfo20->PdbFileName; */
1184 _bfd_XXi_write_codeview_record (bfd
* abfd
, file_ptr where
, CODEVIEW_INFO
*cvinfo
)
1186 const bfd_size_type size
= sizeof (CV_INFO_PDB70
) + 1;
1187 bfd_size_type written
;
1188 CV_INFO_PDB70
*cvinfo70
;
1191 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1194 buffer
= bfd_malloc (size
);
1198 cvinfo70
= (CV_INFO_PDB70
*) buffer
;
1199 H_PUT_32 (abfd
, CVINFO_PDB70_CVSIGNATURE
, cvinfo70
->CvSignature
);
1201 /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1202 in little-endian order, followed by 8 single bytes. */
1203 bfd_putl32 (bfd_getb32 (cvinfo
->Signature
), cvinfo70
->Signature
);
1204 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[4])), &(cvinfo70
->Signature
[4]));
1205 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[6])), &(cvinfo70
->Signature
[6]));
1206 memcpy (&(cvinfo70
->Signature
[8]), &(cvinfo
->Signature
[8]), 8);
1208 H_PUT_32 (abfd
, cvinfo
->Age
, cvinfo70
->Age
);
1209 cvinfo70
->PdbFileName
[0] = '\0';
1211 written
= bfd_bwrite (buffer
, size
, abfd
);
1215 return written
== size
? size
: 0;
1218 static char * dir_names
[IMAGE_NUMBEROF_DIRECTORY_ENTRIES
] =
1220 N_("Export Directory [.edata (or where ever we found it)]"),
1221 N_("Import Directory [parts of .idata]"),
1222 N_("Resource Directory [.rsrc]"),
1223 N_("Exception Directory [.pdata]"),
1224 N_("Security Directory"),
1225 N_("Base Relocation Directory [.reloc]"),
1226 N_("Debug Directory"),
1227 N_("Description Directory"),
1228 N_("Special Directory"),
1229 N_("Thread Storage Directory [.tls]"),
1230 N_("Load Configuration Directory"),
1231 N_("Bound Import Directory"),
1232 N_("Import Address Table Directory"),
1233 N_("Delay Import Directory"),
1234 N_("CLR Runtime Header"),
1239 pe_print_idata (bfd
* abfd
, void * vfile
)
1241 FILE *file
= (FILE *) vfile
;
1245 bfd_size_type datasize
= 0;
1246 bfd_size_type dataoff
;
1250 pe_data_type
*pe
= pe_data (abfd
);
1251 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1255 addr
= extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
;
1257 if (addr
== 0 && extra
->DataDirectory
[PE_IMPORT_TABLE
].Size
== 0)
1259 /* Maybe the extra header isn't there. Look for the section. */
1260 section
= bfd_get_section_by_name (abfd
, ".idata");
1261 if (section
== NULL
)
1264 addr
= section
->vma
;
1265 datasize
= section
->size
;
1271 addr
+= extra
->ImageBase
;
1272 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1274 datasize
= section
->size
;
1275 if (addr
>= section
->vma
&& addr
< section
->vma
+ datasize
)
1279 if (section
== NULL
)
1282 _("\nThere is an import table, but the section containing it could not be found\n"));
1285 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1288 _("\nThere is an import table in %s, but that section has no contents\n"),
1294 /* xgettext:c-format */
1295 fprintf (file
, _("\nThere is an import table in %s at 0x%lx\n"),
1296 section
->name
, (unsigned long) addr
);
1298 dataoff
= addr
- section
->vma
;
1301 _("\nThe Import Tables (interpreted %s section contents)\n"),
1305 vma: Hint Time Forward DLL First\n\
1306 Table Stamp Chain Name Thunk\n"));
1308 /* Read the whole section. Some of the fields might be before dataoff. */
1309 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
1315 adj
= section
->vma
- extra
->ImageBase
;
1317 /* Print all image import descriptors. */
1318 for (i
= dataoff
; i
+ onaline
<= datasize
; i
+= onaline
)
1322 bfd_vma forward_chain
;
1324 bfd_vma first_thunk
;
1329 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1330 fprintf (file
, " %08lx\t", (unsigned long) (i
+ adj
));
1331 hint_addr
= bfd_get_32 (abfd
, data
+ i
);
1332 time_stamp
= bfd_get_32 (abfd
, data
+ i
+ 4);
1333 forward_chain
= bfd_get_32 (abfd
, data
+ i
+ 8);
1334 dll_name
= bfd_get_32 (abfd
, data
+ i
+ 12);
1335 first_thunk
= bfd_get_32 (abfd
, data
+ i
+ 16);
1337 fprintf (file
, "%08lx %08lx %08lx %08lx %08lx\n",
1338 (unsigned long) hint_addr
,
1339 (unsigned long) time_stamp
,
1340 (unsigned long) forward_chain
,
1341 (unsigned long) dll_name
,
1342 (unsigned long) first_thunk
);
1344 if (hint_addr
== 0 && first_thunk
== 0)
1347 if (dll_name
- adj
>= section
->size
)
1350 dll
= (char *) data
+ dll_name
- adj
;
1351 /* PR 17512 file: 078-12277-0.004. */
1352 bfd_size_type maxlen
= (char *)(data
+ datasize
) - dll
- 1;
1353 fprintf (file
, _("\n\tDLL Name: %.*s\n"), (int) maxlen
, dll
);
1355 /* PR 21546: When the Hint Address is zero,
1356 we try the First Thunk instead. */
1358 hint_addr
= first_thunk
;
1360 if (hint_addr
!= 0 && hint_addr
- adj
< datasize
)
1363 asection
*ft_section
;
1365 bfd_size_type ft_datasize
;
1369 fprintf (file
, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1371 idx
= hint_addr
- adj
;
1373 ft_addr
= first_thunk
+ extra
->ImageBase
;
1374 ft_idx
= first_thunk
- adj
;
1375 ft_data
= data
+ ft_idx
;
1376 ft_datasize
= datasize
- ft_idx
;
1379 if (first_thunk
!= hint_addr
)
1381 /* Find the section which contains the first thunk. */
1382 for (ft_section
= abfd
->sections
;
1384 ft_section
= ft_section
->next
)
1386 if (ft_addr
>= ft_section
->vma
1387 && ft_addr
< ft_section
->vma
+ ft_section
->size
)
1391 if (ft_section
== NULL
)
1394 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1398 /* Now check to see if this section is the same as our current
1399 section. If it is not then we will have to load its data in. */
1400 if (ft_section
!= section
)
1402 ft_idx
= first_thunk
- (ft_section
->vma
- extra
->ImageBase
);
1403 ft_datasize
= ft_section
->size
- ft_idx
;
1404 ft_data
= (bfd_byte
*) bfd_malloc (ft_datasize
);
1405 if (ft_data
== NULL
)
1408 /* Read ft_datasize bytes starting at offset ft_idx. */
1409 if (!bfd_get_section_contents (abfd
, ft_section
, ft_data
,
1410 (bfd_vma
) ft_idx
, ft_datasize
))
1419 /* Print HintName vector entries. */
1420 #ifdef COFF_WITH_pex64
1421 for (j
= 0; idx
+ j
+ 8 <= datasize
; j
+= 8)
1424 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1425 unsigned long member_high
= bfd_get_32 (abfd
, data
+ idx
+ j
+ 4);
1427 if (!member
&& !member_high
)
1432 if (HighBitSet (member_high
))
1433 fprintf (file
, "\t%lx%08lx\t %4lx%08lx <none>",
1434 member_high
, member
,
1435 WithoutHighBit (member_high
), member
);
1436 /* PR binutils/17512: Handle corrupt PE data. */
1437 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1438 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1444 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1445 member_name
= (char *) data
+ amt
+ 2;
1446 fprintf (file
, "\t%04lx\t %4d %.*s",member
, ordinal
,
1447 (int) (datasize
- (amt
+ 2)), member_name
);
1450 /* If the time stamp is not zero, the import address
1451 table holds actual addresses. */
1454 && first_thunk
!= hint_addr
1455 && j
+ 4 <= ft_datasize
)
1456 fprintf (file
, "\t%04lx",
1457 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1458 fprintf (file
, "\n");
1461 for (j
= 0; idx
+ j
+ 4 <= datasize
; j
+= 4)
1464 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1466 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1472 if (HighBitSet (member
))
1473 fprintf (file
, "\t%04lx\t %4lu <none>",
1474 member
, WithoutHighBit (member
));
1475 /* PR binutils/17512: Handle corrupt PE data. */
1476 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1477 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1483 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1484 member_name
= (char *) data
+ amt
+ 2;
1485 fprintf (file
, "\t%04lx\t %4d %.*s",
1487 (int) (datasize
- (amt
+ 2)), member_name
);
1490 /* If the time stamp is not zero, the import address
1491 table holds actual addresses. */
1494 && first_thunk
!= hint_addr
1495 && j
+ 4 <= ft_datasize
)
1496 fprintf (file
, "\t%04lx",
1497 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1499 fprintf (file
, "\n");
1506 fprintf (file
, "\n");
1515 pe_print_edata (bfd
* abfd
, void * vfile
)
1517 FILE *file
= (FILE *) vfile
;
1520 bfd_size_type datasize
= 0;
1521 bfd_size_type dataoff
;
1526 long export_flags
; /* Reserved - should be zero. */
1530 bfd_vma name
; /* RVA - relative to image base. */
1531 long base
; /* Ordinal base. */
1532 unsigned long num_functions
;/* Number in the export address table. */
1533 unsigned long num_names
; /* Number in the name pointer table. */
1534 bfd_vma eat_addr
; /* RVA to the export address table. */
1535 bfd_vma npt_addr
; /* RVA to the Export Name Pointer Table. */
1536 bfd_vma ot_addr
; /* RVA to the Ordinal Table. */
1539 pe_data_type
*pe
= pe_data (abfd
);
1540 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1544 addr
= extra
->DataDirectory
[PE_EXPORT_TABLE
].VirtualAddress
;
1546 if (addr
== 0 && extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
== 0)
1548 /* Maybe the extra header isn't there. Look for the section. */
1549 section
= bfd_get_section_by_name (abfd
, ".edata");
1550 if (section
== NULL
)
1553 addr
= section
->vma
;
1555 datasize
= section
->size
;
1561 addr
+= extra
->ImageBase
;
1563 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1564 if (addr
>= section
->vma
&& addr
< section
->vma
+ section
->size
)
1567 if (section
== NULL
)
1570 _("\nThere is an export table, but the section containing it could not be found\n"));
1573 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1576 _("\nThere is an export table in %s, but that section has no contents\n"),
1581 dataoff
= addr
- section
->vma
;
1582 datasize
= extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
;
1583 if (dataoff
> section
->size
1584 || datasize
> section
->size
- dataoff
)
1587 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1593 /* PR 17512: Handle corrupt PE binaries. */
1597 /* xgettext:c-format */
1598 _("\nThere is an export table in %s, but it is too small (%d)\n"),
1599 section
->name
, (int) datasize
);
1603 /* xgettext:c-format */
1604 fprintf (file
, _("\nThere is an export table in %s at 0x%lx\n"),
1605 section
->name
, (unsigned long) addr
);
1607 data
= (bfd_byte
*) bfd_malloc (datasize
);
1611 if (! bfd_get_section_contents (abfd
, section
, data
,
1612 (file_ptr
) dataoff
, datasize
))
1615 /* Go get Export Directory Table. */
1616 edt
.export_flags
= bfd_get_32 (abfd
, data
+ 0);
1617 edt
.time_stamp
= bfd_get_32 (abfd
, data
+ 4);
1618 edt
.major_ver
= bfd_get_16 (abfd
, data
+ 8);
1619 edt
.minor_ver
= bfd_get_16 (abfd
, data
+ 10);
1620 edt
.name
= bfd_get_32 (abfd
, data
+ 12);
1621 edt
.base
= bfd_get_32 (abfd
, data
+ 16);
1622 edt
.num_functions
= bfd_get_32 (abfd
, data
+ 20);
1623 edt
.num_names
= bfd_get_32 (abfd
, data
+ 24);
1624 edt
.eat_addr
= bfd_get_32 (abfd
, data
+ 28);
1625 edt
.npt_addr
= bfd_get_32 (abfd
, data
+ 32);
1626 edt
.ot_addr
= bfd_get_32 (abfd
, data
+ 36);
1628 adj
= section
->vma
- extra
->ImageBase
+ dataoff
;
1630 /* Dump the EDT first. */
1632 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1636 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt
.export_flags
);
1639 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt
.time_stamp
);
1642 /* xgettext:c-format */
1643 _("Major/Minor \t\t\t%d/%d\n"), edt
.major_ver
, edt
.minor_ver
);
1646 _("Name \t\t\t\t"));
1647 bfd_fprintf_vma (abfd
, file
, edt
.name
);
1649 if ((edt
.name
>= adj
) && (edt
.name
< adj
+ datasize
))
1650 fprintf (file
, " %.*s\n",
1651 (int) (datasize
- (edt
.name
- adj
)),
1652 data
+ edt
.name
- adj
);
1654 fprintf (file
, "(outside .edata section)\n");
1657 _("Ordinal Base \t\t\t%ld\n"), edt
.base
);
1663 _("\tExport Address Table \t\t%08lx\n"),
1667 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt
.num_names
);
1670 _("Table Addresses\n"));
1673 _("\tExport Address Table \t\t"));
1674 bfd_fprintf_vma (abfd
, file
, edt
.eat_addr
);
1675 fprintf (file
, "\n");
1678 _("\tName Pointer Table \t\t"));
1679 bfd_fprintf_vma (abfd
, file
, edt
.npt_addr
);
1680 fprintf (file
, "\n");
1683 _("\tOrdinal Table \t\t\t"));
1684 bfd_fprintf_vma (abfd
, file
, edt
.ot_addr
);
1685 fprintf (file
, "\n");
1687 /* The next table to find is the Export Address Table. It's basically
1688 a list of pointers that either locate a function in this dll, or
1689 forward the call to another dll. Something like:
1694 } export_address_table_entry; */
1697 _("\nExport Address Table -- Ordinal Base %ld\n"),
1700 /* PR 17512: Handle corrupt PE binaries. */
1701 /* PR 17512 file: 140-165018-0.004. */
1702 if (edt
.eat_addr
- adj
>= datasize
1703 /* PR 17512: file: 092b1829 */
1704 || (edt
.num_functions
+ 1) * 4 < edt
.num_functions
1705 || edt
.eat_addr
- adj
+ (edt
.num_functions
+ 1) * 4 > datasize
)
1706 fprintf (file
, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1707 (long) edt
.eat_addr
,
1708 (long) edt
.num_functions
);
1709 else for (i
= 0; i
< edt
.num_functions
; ++i
)
1711 bfd_vma eat_member
= bfd_get_32 (abfd
,
1712 data
+ edt
.eat_addr
+ (i
* 4) - adj
);
1713 if (eat_member
== 0)
1716 if (eat_member
- adj
<= datasize
)
1718 /* This rva is to a name (forwarding function) in our section. */
1719 /* Should locate a function descriptor. */
1721 "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1723 (long) (i
+ edt
.base
),
1724 (unsigned long) eat_member
,
1726 (int)(datasize
- (eat_member
- adj
)),
1727 data
+ eat_member
- adj
);
1731 /* Should locate a function descriptor in the reldata section. */
1733 "\t[%4ld] +base[%4ld] %04lx %s\n",
1735 (long) (i
+ edt
.base
),
1736 (unsigned long) eat_member
,
1741 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1742 /* Dump them in parallel for clarity. */
1744 _("\n[Ordinal/Name Pointer] Table\n"));
1746 /* PR 17512: Handle corrupt PE binaries. */
1747 if (edt
.npt_addr
+ (edt
.num_names
* 4) - adj
>= datasize
1748 /* PR 17512: file: bb68816e. */
1749 || edt
.num_names
* 4 < edt
.num_names
1750 || (data
+ edt
.npt_addr
- adj
) < data
)
1751 /* xgettext:c-format */
1752 fprintf (file
, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1753 (long) edt
.npt_addr
,
1754 (long) edt
.num_names
);
1755 /* PR 17512: file: 140-147171-0.004. */
1756 else if (edt
.ot_addr
+ (edt
.num_names
* 2) - adj
>= datasize
1757 || data
+ edt
.ot_addr
- adj
< data
)
1758 /* xgettext:c-format */
1759 fprintf (file
, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1761 (long) edt
.num_names
);
1762 else for (i
= 0; i
< edt
.num_names
; ++i
)
1767 ord
= bfd_get_16 (abfd
, data
+ edt
.ot_addr
+ (i
* 2) - adj
);
1768 name_ptr
= bfd_get_32 (abfd
, data
+ edt
.npt_addr
+ (i
* 4) - adj
);
1770 if ((name_ptr
- adj
) >= datasize
)
1772 /* xgettext:c-format */
1773 fprintf (file
, _("\t[%4ld] <corrupt offset: %lx>\n"),
1774 (long) ord
, (long) name_ptr
);
1778 char * name
= (char *) data
+ name_ptr
- adj
;
1780 fprintf (file
, "\t[%4ld] %.*s\n", (long) ord
,
1781 (int)((char *)(data
+ datasize
) - name
), name
);
1790 /* This really is architecture dependent. On IA-64, a .pdata entry
1791 consists of three dwords containing relative virtual addresses that
1792 specify the start and end address of the code range the entry
1793 covers and the address of the corresponding unwind info data.
1795 On ARM and SH-4, a compressed PDATA structure is used :
1796 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1797 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1798 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1800 This is the version for uncompressed data. */
1803 pe_print_pdata (bfd
* abfd
, void * vfile
)
1805 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1806 # define PDATA_ROW_SIZE (3 * 8)
1808 # define PDATA_ROW_SIZE (5 * 4)
1810 FILE *file
= (FILE *) vfile
;
1812 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1813 bfd_size_type datasize
= 0;
1815 bfd_size_type start
, stop
;
1816 int onaline
= PDATA_ROW_SIZE
;
1819 || coff_section_data (abfd
, section
) == NULL
1820 || pei_section_data (abfd
, section
) == NULL
)
1823 stop
= pei_section_data (abfd
, section
)->virt_size
;
1824 if ((stop
% onaline
) != 0)
1826 /* xgettext:c-format */
1827 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
1828 (long) stop
, onaline
);
1831 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1832 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1834 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1837 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1838 \t\tAddress Address Handler Data Address Mask\n"));
1841 datasize
= section
->size
;
1845 /* PR 17512: file: 002-193900-0.004. */
1846 if (datasize
< stop
)
1848 /* xgettext:c-format */
1849 fprintf (file
, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"),
1850 (long) stop
, (long) datasize
);
1854 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
1862 for (i
= start
; i
< stop
; i
+= onaline
)
1868 bfd_vma prolog_end_addr
;
1869 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1873 if (i
+ PDATA_ROW_SIZE
> stop
)
1876 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
1877 end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
1878 eh_handler
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 8);
1879 eh_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 12);
1880 prolog_end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 16);
1882 if (begin_addr
== 0 && end_addr
== 0 && eh_handler
== 0
1883 && eh_data
== 0 && prolog_end_addr
== 0)
1884 /* We are probably into the padding of the section now. */
1887 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1888 em_data
= ((eh_handler
& 0x1) << 2) | (prolog_end_addr
& 0x3);
1890 eh_handler
&= ~(bfd_vma
) 0x3;
1891 prolog_end_addr
&= ~(bfd_vma
) 0x3;
1894 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
1895 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
1896 bfd_fprintf_vma (abfd
, file
, end_addr
); fputc (' ', file
);
1897 bfd_fprintf_vma (abfd
, file
, eh_handler
);
1898 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1900 bfd_fprintf_vma (abfd
, file
, eh_data
); fputc (' ', file
);
1901 bfd_fprintf_vma (abfd
, file
, prolog_end_addr
);
1902 fprintf (file
, " %x", em_data
);
1904 fprintf (file
, "\n");
1910 #undef PDATA_ROW_SIZE
1913 typedef struct sym_cache
1920 slurp_symtab (bfd
*abfd
, sym_cache
*psc
)
1922 asymbol
** sy
= NULL
;
1925 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1931 storage
= bfd_get_symtab_upper_bound (abfd
);
1936 sy
= (asymbol
**) bfd_malloc (storage
);
1941 psc
->symcount
= bfd_canonicalize_symtab (abfd
, sy
);
1942 if (psc
->symcount
< 0)
1948 my_symbol_for_address (bfd
*abfd
, bfd_vma func
, sym_cache
*psc
)
1953 psc
->syms
= slurp_symtab (abfd
, psc
);
1955 for (i
= 0; i
< psc
->symcount
; i
++)
1957 if (psc
->syms
[i
]->section
->vma
+ psc
->syms
[i
]->value
== func
)
1958 return psc
->syms
[i
]->name
;
1965 cleanup_syms (sym_cache
*psc
)
1972 /* This is the version for "compressed" pdata. */
1975 _bfd_XX_print_ce_compressed_pdata (bfd
* abfd
, void * vfile
)
1977 # define PDATA_ROW_SIZE (2 * 4)
1978 FILE *file
= (FILE *) vfile
;
1979 bfd_byte
*data
= NULL
;
1980 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1981 bfd_size_type datasize
= 0;
1983 bfd_size_type start
, stop
;
1984 int onaline
= PDATA_ROW_SIZE
;
1985 struct sym_cache cache
= {0, 0} ;
1988 || coff_section_data (abfd
, section
) == NULL
1989 || pei_section_data (abfd
, section
) == NULL
)
1992 stop
= pei_section_data (abfd
, section
)->virt_size
;
1993 if ((stop
% onaline
) != 0)
1995 /* xgettext:c-format */
1996 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
1997 (long) stop
, onaline
);
2000 _("\nThe Function Table (interpreted .pdata section contents)\n"));
2003 vma:\t\tBegin Prolog Function Flags Exception EH\n\
2004 \t\tAddress Length Length 32b exc Handler Data\n"));
2006 datasize
= section
->size
;
2010 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2018 for (i
= start
; i
< stop
; i
+= onaline
)
2022 bfd_vma prolog_length
, function_length
;
2023 int flag32bit
, exception_flag
;
2026 if (i
+ PDATA_ROW_SIZE
> stop
)
2029 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
2030 other_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
2032 if (begin_addr
== 0 && other_data
== 0)
2033 /* We are probably into the padding of the section now. */
2036 prolog_length
= (other_data
& 0x000000FF);
2037 function_length
= (other_data
& 0x3FFFFF00) >> 8;
2038 flag32bit
= (int)((other_data
& 0x40000000) >> 30);
2039 exception_flag
= (int)((other_data
& 0x80000000) >> 31);
2042 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
2043 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
2044 bfd_fprintf_vma (abfd
, file
, prolog_length
); fputc (' ', file
);
2045 bfd_fprintf_vma (abfd
, file
, function_length
); fputc (' ', file
);
2046 fprintf (file
, "%2d %2d ", flag32bit
, exception_flag
);
2048 /* Get the exception handler's address and the data passed from the
2049 .text section. This is really the data that belongs with the .pdata
2050 but got "compressed" out for the ARM and SH4 architectures. */
2051 tsection
= bfd_get_section_by_name (abfd
, ".text");
2052 if (tsection
&& coff_section_data (abfd
, tsection
)
2053 && pei_section_data (abfd
, tsection
))
2055 bfd_vma eh_off
= (begin_addr
- 8) - tsection
->vma
;
2058 tdata
= (bfd_byte
*) bfd_malloc (8);
2061 if (bfd_get_section_contents (abfd
, tsection
, tdata
, eh_off
, 8))
2063 bfd_vma eh
, eh_data
;
2065 eh
= bfd_get_32 (abfd
, tdata
);
2066 eh_data
= bfd_get_32 (abfd
, tdata
+ 4);
2067 fprintf (file
, "%08x ", (unsigned int) eh
);
2068 fprintf (file
, "%08x", (unsigned int) eh_data
);
2071 const char *s
= my_symbol_for_address (abfd
, eh
, &cache
);
2074 fprintf (file
, " (%s) ", s
);
2081 fprintf (file
, "\n");
2086 cleanup_syms (& cache
);
2089 #undef PDATA_ROW_SIZE
2093 #define IMAGE_REL_BASED_HIGHADJ 4
2094 static const char * const tbl
[] =
2108 "UNKNOWN", /* MUST be last. */
2112 pe_print_reloc (bfd
* abfd
, void * vfile
)
2114 FILE *file
= (FILE *) vfile
;
2116 asection
*section
= bfd_get_section_by_name (abfd
, ".reloc");
2119 if (section
== NULL
|| section
->size
== 0 || !(section
->flags
& SEC_HAS_CONTENTS
))
2123 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2125 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2132 end
= data
+ section
->size
;
2133 while (p
+ 8 <= end
)
2136 bfd_vma virtual_address
;
2137 unsigned long number
, size
;
2138 bfd_byte
*chunk_end
;
2140 /* The .reloc section is a sequence of blocks, with a header consisting
2141 of two 32 bit quantities, followed by a number of 16 bit entries. */
2142 virtual_address
= bfd_get_32 (abfd
, p
);
2143 size
= bfd_get_32 (abfd
, p
+ 4);
2145 number
= (size
- 8) / 2;
2151 /* xgettext:c-format */
2152 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2153 (unsigned long) virtual_address
, size
, size
, number
);
2155 chunk_end
= p
- 8 + size
;
2156 if (chunk_end
> end
)
2159 while (p
+ 2 <= chunk_end
)
2161 unsigned short e
= bfd_get_16 (abfd
, p
);
2162 unsigned int t
= (e
& 0xF000) >> 12;
2163 int off
= e
& 0x0FFF;
2165 if (t
>= sizeof (tbl
) / sizeof (tbl
[0]))
2166 t
= (sizeof (tbl
) / sizeof (tbl
[0])) - 1;
2169 /* xgettext:c-format */
2170 _("\treloc %4d offset %4x [%4lx] %s"),
2171 j
, off
, (unsigned long) (off
+ virtual_address
), tbl
[t
]);
2176 /* HIGHADJ takes an argument, - the next record *is* the
2177 low 16 bits of addend. */
2178 if (t
== IMAGE_REL_BASED_HIGHADJ
&& p
+ 2 <= chunk_end
)
2180 fprintf (file
, " (%4x)", (unsigned int) bfd_get_16 (abfd
, p
));
2185 fprintf (file
, "\n");
2194 /* A data structure describing the regions of a .rsrc section.
2195 Some fields are filled in as the section is parsed. */
2197 typedef struct rsrc_regions
2199 bfd_byte
* section_start
;
2200 bfd_byte
* section_end
;
2201 bfd_byte
* strings_start
;
2202 bfd_byte
* resource_start
;
2206 rsrc_print_resource_directory (FILE * , bfd
*, unsigned int, bfd_byte
*,
2207 rsrc_regions
*, bfd_vma
);
2209 /* Print the resource entry at DATA, with the text indented by INDENT.
2210 Recusively calls rsrc_print_resource_directory to print the contents
2211 of directory entries.
2212 Returns the address of the end of the data associated with the entry
2213 or section_end + 1 upon failure. */
2216 rsrc_print_resource_entries (FILE * file
,
2218 unsigned int indent
,
2219 bfd_boolean is_name
,
2221 rsrc_regions
* regions
,
2224 unsigned long entry
, addr
, size
;
2227 if (data
+ 8 >= regions
->section_end
)
2228 return regions
->section_end
+ 1;
2230 /* xgettext:c-format */
2231 fprintf (file
, _("%03x %*.s Entry: "), (int)(data
- regions
->section_start
), indent
, " ");
2233 entry
= (unsigned long) bfd_get_32 (abfd
, data
);
2238 /* Note - the documentation says that this field is an RVA value
2239 but windres appears to produce a section relative offset with
2240 the top bit set. Support both styles for now. */
2241 if (HighBitSet (entry
))
2242 name
= regions
->section_start
+ WithoutHighBit (entry
);
2244 name
= regions
->section_start
+ entry
- rva_bias
;
2246 if (name
+ 2 < regions
->section_end
&& name
> regions
->section_start
)
2250 if (regions
->strings_start
== NULL
)
2251 regions
->strings_start
= name
;
2253 len
= bfd_get_16 (abfd
, name
);
2255 fprintf (file
, _("name: [val: %08lx len %d]: "), entry
, len
);
2257 if (name
+ 2 + len
* 2 < regions
->section_end
)
2259 /* This strange loop is to cope with multibyte characters. */
2266 /* Avoid printing control characters. */
2267 if (c
> 0 && c
< 32)
2268 fprintf (file
, "^%c", c
+ 64);
2270 fprintf (file
, "%.1s", name
);
2275 fprintf (file
, _("<corrupt string length: %#x>\n"), len
);
2276 /* PR binutils/17512: Do not try to continue decoding a
2277 corrupted resource section. It is likely to end up with
2278 reams of extraneous output. FIXME: We could probably
2279 continue if we disable the printing of strings... */
2280 return regions
->section_end
+ 1;
2285 fprintf (file
, _("<corrupt string offset: %#lx>\n"), entry
);
2286 return regions
->section_end
+ 1;
2290 fprintf (file
, _("ID: %#08lx"), entry
);
2292 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
2293 fprintf (file
, _(", Value: %#08lx\n"), entry
);
2295 if (HighBitSet (entry
))
2297 data
= regions
->section_start
+ WithoutHighBit (entry
);
2298 if (data
<= regions
->section_start
|| data
> regions
->section_end
)
2299 return regions
->section_end
+ 1;
2301 /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2302 in the resource table. We need some way to detect this. */
2303 return rsrc_print_resource_directory (file
, abfd
, indent
+ 1, data
,
2307 leaf
= regions
->section_start
+ entry
;
2309 if (leaf
+ 16 >= regions
->section_end
2310 /* PR 17512: file: 055dff7e. */
2311 || leaf
< regions
->section_start
)
2312 return regions
->section_end
+ 1;
2314 /* xgettext:c-format */
2315 fprintf (file
, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2316 (int) (entry
), indent
, " ",
2317 addr
= (long) bfd_get_32 (abfd
, leaf
),
2318 size
= (long) bfd_get_32 (abfd
, leaf
+ 4),
2319 (int) bfd_get_32 (abfd
, leaf
+ 8));
2321 /* Check that the reserved entry is 0. */
2322 if (bfd_get_32 (abfd
, leaf
+ 12) != 0
2323 /* And that the data address/size is valid too. */
2324 || (regions
->section_start
+ (addr
- rva_bias
) + size
> regions
->section_end
))
2325 return regions
->section_end
+ 1;
2327 if (regions
->resource_start
== NULL
)
2328 regions
->resource_start
= regions
->section_start
+ (addr
- rva_bias
);
2330 return regions
->section_start
+ (addr
- rva_bias
) + size
;
2333 #define max(a,b) ((a) > (b) ? (a) : (b))
2334 #define min(a,b) ((a) < (b) ? (a) : (b))
2337 rsrc_print_resource_directory (FILE * file
,
2339 unsigned int indent
,
2341 rsrc_regions
* regions
,
2344 unsigned int num_names
, num_ids
;
2345 bfd_byte
* highest_data
= data
;
2347 if (data
+ 16 >= regions
->section_end
)
2348 return regions
->section_end
+ 1;
2350 fprintf (file
, "%03x %*.s ", (int)(data
- regions
->section_start
), indent
, " ");
2353 case 0: fprintf (file
, "Type"); break;
2354 case 2: fprintf (file
, "Name"); break;
2355 case 4: fprintf (file
, "Language"); break;
2357 fprintf (file
, _("<unknown directory type: %d>\n"), indent
);
2358 /* FIXME: For now we end the printing here. If in the
2359 future more directory types are added to the RSRC spec
2360 then we will need to change this. */
2361 return regions
->section_end
+ 1;
2364 /* xgettext:c-format */
2365 fprintf (file
, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2366 (int) bfd_get_32 (abfd
, data
),
2367 (long) bfd_get_32 (abfd
, data
+ 4),
2368 (int) bfd_get_16 (abfd
, data
+ 8),
2369 (int) bfd_get_16 (abfd
, data
+ 10),
2370 num_names
= (int) bfd_get_16 (abfd
, data
+ 12),
2371 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14));
2374 while (num_names
--)
2376 bfd_byte
* entry_end
;
2378 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, TRUE
,
2379 data
, regions
, rva_bias
);
2381 highest_data
= max (highest_data
, entry_end
);
2382 if (entry_end
>= regions
->section_end
)
2388 bfd_byte
* entry_end
;
2390 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, FALSE
,
2391 data
, regions
, rva_bias
);
2393 highest_data
= max (highest_data
, entry_end
);
2394 if (entry_end
>= regions
->section_end
)
2398 return max (highest_data
, data
);
2401 /* Display the contents of a .rsrc section. We do not try to
2402 reproduce the resources, windres does that. Instead we dump
2403 the tables in a human readable format. */
2406 rsrc_print_section (bfd
* abfd
, void * vfile
)
2410 FILE * file
= (FILE *) vfile
;
2411 bfd_size_type datasize
;
2414 rsrc_regions regions
;
2416 pe
= pe_data (abfd
);
2420 section
= bfd_get_section_by_name (abfd
, ".rsrc");
2421 if (section
== NULL
)
2423 if (!(section
->flags
& SEC_HAS_CONTENTS
))
2426 datasize
= section
->size
;
2430 rva_bias
= section
->vma
- pe
->pe_opthdr
.ImageBase
;
2432 if (! bfd_malloc_and_get_section (abfd
, section
, & data
))
2438 regions
.section_start
= data
;
2439 regions
.section_end
= data
+ datasize
;
2440 regions
.strings_start
= NULL
;
2441 regions
.resource_start
= NULL
;
2444 fprintf (file
, "\nThe .rsrc Resource Directory section:\n");
2446 while (data
< regions
.section_end
)
2448 bfd_byte
* p
= data
;
2450 data
= rsrc_print_resource_directory (file
, abfd
, 0, data
, & regions
, rva_bias
);
2452 if (data
== regions
.section_end
+ 1)
2453 fprintf (file
, _("Corrupt .rsrc section detected!\n"));
2456 /* Align data before continuing. */
2457 int align
= (1 << section
->alignment_power
) - 1;
2459 data
= (bfd_byte
*) (((ptrdiff_t) (data
+ align
)) & ~ align
);
2460 rva_bias
+= data
- p
;
2462 /* For reasons that are unclear .rsrc sections are sometimes created
2463 aligned to a 1^3 boundary even when their alignment is set at
2464 1^2. Catch that case here before we issue a spurious warning
2466 if (data
== (regions
.section_end
- 4))
2467 data
= regions
.section_end
;
2468 else if (data
< regions
.section_end
)
2470 /* If the extra data is all zeros then do not complain.
2471 This is just padding so that the section meets the
2472 page size requirements. */
2473 while (++ data
< regions
.section_end
)
2476 if (data
< regions
.section_end
)
2477 fprintf (file
, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2482 if (regions
.strings_start
!= NULL
)
2483 fprintf (file
, _(" String table starts at offset: %#03x\n"),
2484 (int) (regions
.strings_start
- regions
.section_start
));
2485 if (regions
.resource_start
!= NULL
)
2486 fprintf (file
, _(" Resources start at offset: %#03x\n"),
2487 (int) (regions
.resource_start
- regions
.section_start
));
2489 free (regions
.section_start
);
2493 #define IMAGE_NUMBEROF_DEBUG_TYPES 17
2495 static char * debug_type_names
[IMAGE_NUMBEROF_DEBUG_TYPES
] =
2517 pe_print_debugdata (bfd
* abfd
, void * vfile
)
2519 FILE *file
= (FILE *) vfile
;
2520 pe_data_type
*pe
= pe_data (abfd
);
2521 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2524 bfd_size_type dataoff
;
2527 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2528 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2533 addr
+= extra
->ImageBase
;
2534 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2536 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2540 if (section
== NULL
)
2543 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2546 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
2549 _("\nThere is a debug directory in %s, but that section has no contents\n"),
2553 else if (section
->size
< size
)
2556 _("\nError: section %s contains the debug data starting address but it is too small\n"),
2561 fprintf (file
, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2562 section
->name
, (unsigned long) addr
);
2564 dataoff
= addr
- section
->vma
;
2566 if (size
> (section
->size
- dataoff
))
2568 fprintf (file
, _("The debug data size field in the data directory is too big for the section"));
2573 _("Type Size Rva Offset\n"));
2575 /* Read the whole section. */
2576 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2582 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2584 const char *type_name
;
2585 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2586 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2587 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2589 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2591 if ((idd
.Type
) >= IMAGE_NUMBEROF_DEBUG_TYPES
)
2592 type_name
= debug_type_names
[0];
2594 type_name
= debug_type_names
[idd
.Type
];
2596 fprintf (file
, " %2ld %14s %08lx %08lx %08lx\n",
2597 idd
.Type
, type_name
, idd
.SizeOfData
,
2598 idd
.AddressOfRawData
, idd
.PointerToRawData
);
2600 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_CODEVIEW
)
2602 char signature
[CV_INFO_SIGNATURE_LENGTH
* 2 + 1];
2603 /* PR 17512: file: 065-29434-0.001:0.1
2604 We need to use a 32-bit aligned buffer
2605 to safely read in a codeview record. */
2606 char buffer
[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO
);
2608 CODEVIEW_INFO
*cvinfo
= (CODEVIEW_INFO
*) buffer
;
2610 /* The debug entry doesn't have to have to be in a section,
2611 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2612 if (!_bfd_XXi_slurp_codeview_record (abfd
, (file_ptr
) idd
.PointerToRawData
,
2613 idd
.SizeOfData
, cvinfo
))
2616 for (j
= 0; j
< cvinfo
->SignatureLength
; j
++)
2617 sprintf (&signature
[j
*2], "%02x", cvinfo
->Signature
[j
] & 0xff);
2619 /* xgettext:c-format */
2620 fprintf (file
, _("(format %c%c%c%c signature %s age %ld)\n"),
2621 buffer
[0], buffer
[1], buffer
[2], buffer
[3],
2622 signature
, cvinfo
->Age
);
2628 if (size
% sizeof (struct external_IMAGE_DEBUG_DIRECTORY
) != 0)
2630 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2636 pe_is_repro (bfd
* abfd
)
2638 pe_data_type
*pe
= pe_data (abfd
);
2639 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2642 bfd_size_type dataoff
;
2644 bfd_boolean res
= FALSE
;
2646 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2647 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2652 addr
+= extra
->ImageBase
;
2653 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2655 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2659 if ((section
== NULL
)
2660 || (!(section
->flags
& SEC_HAS_CONTENTS
))
2661 || (section
->size
< size
))
2666 dataoff
= addr
- section
->vma
;
2668 if (size
> (section
->size
- dataoff
))
2673 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2679 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2681 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2682 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2683 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2685 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2687 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_REPRO
)
2699 /* Print out the program headers. */
2702 _bfd_XX_print_private_bfd_data_common (bfd
* abfd
, void * vfile
)
2704 FILE *file
= (FILE *) vfile
;
2706 pe_data_type
*pe
= pe_data (abfd
);
2707 struct internal_extra_pe_aouthdr
*i
= &pe
->pe_opthdr
;
2708 const char *subsystem_name
= NULL
;
2711 /* The MS dumpbin program reportedly ands with 0xff0f before
2712 printing the characteristics field. Not sure why. No reason to
2714 fprintf (file
, _("\nCharacteristics 0x%x\n"), pe
->real_flags
);
2716 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2717 PF (IMAGE_FILE_RELOCS_STRIPPED
, "relocations stripped");
2718 PF (IMAGE_FILE_EXECUTABLE_IMAGE
, "executable");
2719 PF (IMAGE_FILE_LINE_NUMS_STRIPPED
, "line numbers stripped");
2720 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED
, "symbols stripped");
2721 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE
, "large address aware");
2722 PF (IMAGE_FILE_BYTES_REVERSED_LO
, "little endian");
2723 PF (IMAGE_FILE_32BIT_MACHINE
, "32 bit words");
2724 PF (IMAGE_FILE_DEBUG_STRIPPED
, "debugging information removed");
2725 PF (IMAGE_FILE_SYSTEM
, "system file");
2726 PF (IMAGE_FILE_DLL
, "DLL");
2727 PF (IMAGE_FILE_BYTES_REVERSED_HI
, "big endian");
2731 If a PE_IMAGE_DEBUG_TYPE_REPRO entry is present in the debug directory, the
2732 timestamp is to be interpreted as the hash of a reproducible build.
2734 if (pe_is_repro (abfd
))
2736 fprintf (file
, "\nTime/Date\t\t%08lx", pe
->coff
.timestamp
);
2737 fprintf (file
, "\t(This is a reproducible build file hash, not a timestamp)\n");
2741 /* ctime implies '\n'. */
2742 time_t t
= pe
->coff
.timestamp
;
2743 fprintf (file
, "\nTime/Date\t\t%s", ctime (&t
));
2746 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2747 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2749 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2750 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2752 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2753 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2758 case IMAGE_NT_OPTIONAL_HDR_MAGIC
:
2761 case IMAGE_NT_OPTIONAL_HDR64_MAGIC
:
2764 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC
:
2771 fprintf (file
, "Magic\t\t\t%04x", i
->Magic
);
2773 fprintf (file
, "\t(%s)",name
);
2774 fprintf (file
, "\nMajorLinkerVersion\t%d\n", i
->MajorLinkerVersion
);
2775 fprintf (file
, "MinorLinkerVersion\t%d\n", i
->MinorLinkerVersion
);
2776 fprintf (file
, "SizeOfCode\t\t");
2777 bfd_fprintf_vma (abfd
, file
, i
->SizeOfCode
);
2778 fprintf (file
, "\nSizeOfInitializedData\t");
2779 bfd_fprintf_vma (abfd
, file
, i
->SizeOfInitializedData
);
2780 fprintf (file
, "\nSizeOfUninitializedData\t");
2781 bfd_fprintf_vma (abfd
, file
, i
->SizeOfUninitializedData
);
2782 fprintf (file
, "\nAddressOfEntryPoint\t");
2783 bfd_fprintf_vma (abfd
, file
, i
->AddressOfEntryPoint
);
2784 fprintf (file
, "\nBaseOfCode\t\t");
2785 bfd_fprintf_vma (abfd
, file
, i
->BaseOfCode
);
2786 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2787 /* PE32+ does not have BaseOfData member! */
2788 fprintf (file
, "\nBaseOfData\t\t");
2789 bfd_fprintf_vma (abfd
, file
, i
->BaseOfData
);
2792 fprintf (file
, "\nImageBase\t\t");
2793 bfd_fprintf_vma (abfd
, file
, i
->ImageBase
);
2794 fprintf (file
, "\nSectionAlignment\t%08x\n", i
->SectionAlignment
);
2795 fprintf (file
, "FileAlignment\t\t%08x\n", i
->FileAlignment
);
2796 fprintf (file
, "MajorOSystemVersion\t%d\n", i
->MajorOperatingSystemVersion
);
2797 fprintf (file
, "MinorOSystemVersion\t%d\n", i
->MinorOperatingSystemVersion
);
2798 fprintf (file
, "MajorImageVersion\t%d\n", i
->MajorImageVersion
);
2799 fprintf (file
, "MinorImageVersion\t%d\n", i
->MinorImageVersion
);
2800 fprintf (file
, "MajorSubsystemVersion\t%d\n", i
->MajorSubsystemVersion
);
2801 fprintf (file
, "MinorSubsystemVersion\t%d\n", i
->MinorSubsystemVersion
);
2802 fprintf (file
, "Win32Version\t\t%08x\n", i
->Reserved1
);
2803 fprintf (file
, "SizeOfImage\t\t%08x\n", i
->SizeOfImage
);
2804 fprintf (file
, "SizeOfHeaders\t\t%08x\n", i
->SizeOfHeaders
);
2805 fprintf (file
, "CheckSum\t\t%08x\n", i
->CheckSum
);
2807 switch (i
->Subsystem
)
2809 case IMAGE_SUBSYSTEM_UNKNOWN
:
2810 subsystem_name
= "unspecified";
2812 case IMAGE_SUBSYSTEM_NATIVE
:
2813 subsystem_name
= "NT native";
2815 case IMAGE_SUBSYSTEM_WINDOWS_GUI
:
2816 subsystem_name
= "Windows GUI";
2818 case IMAGE_SUBSYSTEM_WINDOWS_CUI
:
2819 subsystem_name
= "Windows CUI";
2821 case IMAGE_SUBSYSTEM_POSIX_CUI
:
2822 subsystem_name
= "POSIX CUI";
2824 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI
:
2825 subsystem_name
= "Wince CUI";
2827 /* These are from UEFI Platform Initialization Specification 1.1. */
2828 case IMAGE_SUBSYSTEM_EFI_APPLICATION
:
2829 subsystem_name
= "EFI application";
2831 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
:
2832 subsystem_name
= "EFI boot service driver";
2834 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
:
2835 subsystem_name
= "EFI runtime driver";
2837 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER
:
2838 subsystem_name
= "SAL runtime driver";
2840 /* This is from revision 8.0 of the MS PE/COFF spec */
2841 case IMAGE_SUBSYSTEM_XBOX
:
2842 subsystem_name
= "XBOX";
2844 /* Added default case for clarity - subsystem_name is NULL anyway. */
2846 subsystem_name
= NULL
;
2849 fprintf (file
, "Subsystem\t\t%08x", i
->Subsystem
);
2851 fprintf (file
, "\t(%s)", subsystem_name
);
2852 fprintf (file
, "\nDllCharacteristics\t%08x\n", i
->DllCharacteristics
);
2853 fprintf (file
, "SizeOfStackReserve\t");
2854 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackReserve
);
2855 fprintf (file
, "\nSizeOfStackCommit\t");
2856 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackCommit
);
2857 fprintf (file
, "\nSizeOfHeapReserve\t");
2858 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapReserve
);
2859 fprintf (file
, "\nSizeOfHeapCommit\t");
2860 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapCommit
);
2861 fprintf (file
, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i
->LoaderFlags
);
2862 fprintf (file
, "NumberOfRvaAndSizes\t%08lx\n",
2863 (unsigned long) i
->NumberOfRvaAndSizes
);
2865 fprintf (file
, "\nThe Data Directory\n");
2866 for (j
= 0; j
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; j
++)
2868 fprintf (file
, "Entry %1x ", j
);
2869 bfd_fprintf_vma (abfd
, file
, i
->DataDirectory
[j
].VirtualAddress
);
2870 fprintf (file
, " %08lx ", (unsigned long) i
->DataDirectory
[j
].Size
);
2871 fprintf (file
, "%s\n", dir_names
[j
]);
2874 pe_print_idata (abfd
, vfile
);
2875 pe_print_edata (abfd
, vfile
);
2876 if (bfd_coff_have_print_pdata (abfd
))
2877 bfd_coff_print_pdata (abfd
, vfile
);
2879 pe_print_pdata (abfd
, vfile
);
2880 pe_print_reloc (abfd
, vfile
);
2881 pe_print_debugdata (abfd
, file
);
2883 rsrc_print_section (abfd
, vfile
);
2889 is_vma_in_section (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sect
, void *obj
)
2891 bfd_vma addr
= * (bfd_vma
*) obj
;
2892 return (addr
>= sect
->vma
) && (addr
< (sect
->vma
+ sect
->size
));
2896 find_section_by_vma (bfd
*abfd
, bfd_vma addr
)
2898 return bfd_sections_find_if (abfd
, is_vma_in_section
, (void *) & addr
);
2901 /* Copy any private info we understand from the input bfd
2902 to the output bfd. */
2905 _bfd_XX_bfd_copy_private_bfd_data_common (bfd
* ibfd
, bfd
* obfd
)
2907 pe_data_type
*ipe
, *ope
;
2909 /* One day we may try to grok other private data. */
2910 if (ibfd
->xvec
->flavour
!= bfd_target_coff_flavour
2911 || obfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
2914 ipe
= pe_data (ibfd
);
2915 ope
= pe_data (obfd
);
2917 /* pe_opthdr is copied in copy_object. */
2918 ope
->dll
= ipe
->dll
;
2920 /* Don't copy input subsystem if output is different from input. */
2921 if (obfd
->xvec
!= ibfd
->xvec
)
2922 ope
->pe_opthdr
.Subsystem
= IMAGE_SUBSYSTEM_UNKNOWN
;
2924 /* For strip: if we removed .reloc, we'll make a real mess of things
2925 if we don't remove this entry as well. */
2926 if (! pe_data (obfd
)->has_reloc_section
)
2928 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].VirtualAddress
= 0;
2929 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].Size
= 0;
2932 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2933 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2935 if (! pe_data (ibfd
)->has_reloc_section
2936 && ! (pe_data (ibfd
)->real_flags
& IMAGE_FILE_RELOCS_STRIPPED
))
2937 pe_data (obfd
)->dont_strip_reloc
= 1;
2939 memcpy (ope
->dos_message
, ipe
->dos_message
, sizeof (ope
->dos_message
));
2941 /* The file offsets contained in the debug directory need rewriting. */
2942 if (ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
!= 0)
2944 bfd_vma addr
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
2945 + ope
->pe_opthdr
.ImageBase
;
2946 asection
*section
= find_section_by_vma (obfd
, addr
);
2949 if (section
&& bfd_malloc_and_get_section (obfd
, section
, &data
))
2952 struct external_IMAGE_DEBUG_DIRECTORY
*dd
=
2953 (struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ (addr
- section
->vma
));
2955 /* PR 17512: file: 0f15796a. */
2956 if ((unsigned long) ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
2957 > section
->size
- (addr
- section
->vma
))
2959 /* xgettext:c-format */
2961 (_("%pB: Data Directory size (%lx) "
2962 "exceeds space left in section (%" PRIx64
")"),
2963 obfd
, ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
,
2964 (uint64_t) (section
->size
- (addr
- section
->vma
)));
2969 for (i
= 0; i
< ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
2970 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2972 asection
*ddsection
;
2973 struct external_IMAGE_DEBUG_DIRECTORY
*edd
= &(dd
[i
]);
2974 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2976 _bfd_XXi_swap_debugdir_in (obfd
, edd
, &idd
);
2978 if (idd
.AddressOfRawData
== 0)
2979 continue; /* RVA 0 means only offset is valid, not handled yet. */
2981 ddsection
= find_section_by_vma (obfd
, idd
.AddressOfRawData
+ ope
->pe_opthdr
.ImageBase
);
2983 continue; /* Not in a section! */
2985 idd
.PointerToRawData
= ddsection
->filepos
+ (idd
.AddressOfRawData
2986 + ope
->pe_opthdr
.ImageBase
) - ddsection
->vma
;
2988 _bfd_XXi_swap_debugdir_out (obfd
, &idd
, edd
);
2991 if (!bfd_set_section_contents (obfd
, section
, data
, 0, section
->size
))
2993 _bfd_error_handler (_("failed to update file offsets in debug directory"));
3001 _bfd_error_handler (_("%pB: failed to read debug data section"), obfd
);
3009 /* Copy private section data. */
3012 _bfd_XX_bfd_copy_private_section_data (bfd
*ibfd
,
3017 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
3018 || bfd_get_flavour (obfd
) != bfd_target_coff_flavour
)
3021 if (coff_section_data (ibfd
, isec
) != NULL
3022 && pei_section_data (ibfd
, isec
) != NULL
)
3024 if (coff_section_data (obfd
, osec
) == NULL
)
3026 size_t amt
= sizeof (struct coff_section_tdata
);
3027 osec
->used_by_bfd
= bfd_zalloc (obfd
, amt
);
3028 if (osec
->used_by_bfd
== NULL
)
3032 if (pei_section_data (obfd
, osec
) == NULL
)
3034 size_t amt
= sizeof (struct pei_section_tdata
);
3035 coff_section_data (obfd
, osec
)->tdata
= bfd_zalloc (obfd
, amt
);
3036 if (coff_section_data (obfd
, osec
)->tdata
== NULL
)
3040 pei_section_data (obfd
, osec
)->virt_size
=
3041 pei_section_data (ibfd
, isec
)->virt_size
;
3042 pei_section_data (obfd
, osec
)->pe_flags
=
3043 pei_section_data (ibfd
, isec
)->pe_flags
;
3050 _bfd_XX_get_symbol_info (bfd
* abfd
, asymbol
*symbol
, symbol_info
*ret
)
3052 coff_get_symbol_info (abfd
, symbol
, ret
);
3055 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
3057 sort_x64_pdata (const void *l
, const void *r
)
3059 const char *lp
= (const char *) l
;
3060 const char *rp
= (const char *) r
;
3062 vl
= bfd_getl32 (lp
); vr
= bfd_getl32 (rp
);
3064 return (vl
< vr
? -1 : 1);
3065 /* We compare just begin address. */
3070 /* Functions to process a .rsrc section. */
3072 static unsigned int sizeof_leaves
;
3073 static unsigned int sizeof_strings
;
3074 static unsigned int sizeof_tables_and_entries
;
3077 rsrc_count_directory (bfd
*, bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
3080 rsrc_count_entries (bfd
* abfd
,
3081 bfd_boolean is_name
,
3082 bfd_byte
* datastart
,
3087 unsigned long entry
, addr
, size
;
3089 if (data
+ 8 >= dataend
)
3096 entry
= (long) bfd_get_32 (abfd
, data
);
3098 if (HighBitSet (entry
))
3099 name
= datastart
+ WithoutHighBit (entry
);
3101 name
= datastart
+ entry
- rva_bias
;
3103 if (name
+ 2 >= dataend
|| name
< datastart
)
3106 unsigned int len
= bfd_get_16 (abfd
, name
);
3107 if (len
== 0 || len
> 256)
3111 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
3113 if (HighBitSet (entry
))
3115 data
= datastart
+ WithoutHighBit (entry
);
3117 if (data
<= datastart
|| data
>= dataend
)
3120 return rsrc_count_directory (abfd
, datastart
, data
, dataend
, rva_bias
);
3123 if (datastart
+ entry
+ 16 >= dataend
)
3126 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
);
3127 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4);
3129 return datastart
+ addr
- rva_bias
+ size
;
3133 rsrc_count_directory (bfd
* abfd
,
3134 bfd_byte
* datastart
,
3139 unsigned int num_entries
, num_ids
;
3140 bfd_byte
* highest_data
= data
;
3142 if (data
+ 16 >= dataend
)
3145 num_entries
= (int) bfd_get_16 (abfd
, data
+ 12);
3146 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14);
3148 num_entries
+= num_ids
;
3152 while (num_entries
--)
3154 bfd_byte
* entry_end
;
3156 entry_end
= rsrc_count_entries (abfd
, num_entries
>= num_ids
,
3157 datastart
, data
, dataend
, rva_bias
);
3159 highest_data
= max (highest_data
, entry_end
);
3160 if (entry_end
>= dataend
)
3164 return max (highest_data
, data
);
3167 typedef struct rsrc_dir_chain
3169 unsigned int num_entries
;
3170 struct rsrc_entry
* first_entry
;
3171 struct rsrc_entry
* last_entry
;
3174 typedef struct rsrc_directory
3176 unsigned int characteristics
;
3181 rsrc_dir_chain names
;
3184 struct rsrc_entry
* entry
;
3187 typedef struct rsrc_string
3193 typedef struct rsrc_leaf
3196 unsigned int codepage
;
3200 typedef struct rsrc_entry
3202 bfd_boolean is_name
;
3206 struct rsrc_string name
;
3212 struct rsrc_directory
* directory
;
3213 struct rsrc_leaf
* leaf
;
3216 struct rsrc_entry
* next_entry
;
3217 struct rsrc_directory
* parent
;
3221 rsrc_parse_directory (bfd
*, rsrc_directory
*, bfd_byte
*,
3222 bfd_byte
*, bfd_byte
*, bfd_vma
, rsrc_entry
*);
3225 rsrc_parse_entry (bfd
* abfd
,
3226 bfd_boolean is_name
,
3228 bfd_byte
* datastart
,
3232 rsrc_directory
* parent
)
3234 unsigned long val
, addr
, size
;
3236 val
= bfd_get_32 (abfd
, data
);
3238 entry
->parent
= parent
;
3239 entry
->is_name
= is_name
;
3245 if (HighBitSet (val
))
3247 val
= WithoutHighBit (val
);
3249 address
= datastart
+ val
;
3253 address
= datastart
+ val
- rva_bias
;
3256 if (address
+ 3 > dataend
)
3259 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, address
);
3260 entry
->name_id
.name
.string
= address
+ 2;
3263 entry
->name_id
.id
= val
;
3265 val
= bfd_get_32 (abfd
, data
+ 4);
3267 if (HighBitSet (val
))
3269 entry
->is_dir
= TRUE
;
3270 entry
->value
.directory
= bfd_malloc (sizeof * entry
->value
.directory
);
3271 if (entry
->value
.directory
== NULL
)
3274 return rsrc_parse_directory (abfd
, entry
->value
.directory
,
3276 datastart
+ WithoutHighBit (val
),
3277 dataend
, rva_bias
, entry
);
3280 entry
->is_dir
= FALSE
;
3281 entry
->value
.leaf
= bfd_malloc (sizeof * entry
->value
.leaf
);
3282 if (entry
->value
.leaf
== NULL
)
3285 data
= datastart
+ val
;
3286 if (data
< datastart
|| data
>= dataend
)
3289 addr
= bfd_get_32 (abfd
, data
);
3290 size
= entry
->value
.leaf
->size
= bfd_get_32 (abfd
, data
+ 4);
3291 entry
->value
.leaf
->codepage
= bfd_get_32 (abfd
, data
+ 8);
3292 /* FIXME: We assume that the reserved field (data + 12) is OK. */
3294 entry
->value
.leaf
->data
= bfd_malloc (size
);
3295 if (entry
->value
.leaf
->data
== NULL
)
3298 memcpy (entry
->value
.leaf
->data
, datastart
+ addr
- rva_bias
, size
);
3299 return datastart
+ (addr
- rva_bias
) + size
;
3303 rsrc_parse_entries (bfd
* abfd
,
3304 rsrc_dir_chain
* chain
,
3305 bfd_boolean is_name
,
3306 bfd_byte
* highest_data
,
3307 bfd_byte
* datastart
,
3311 rsrc_directory
* parent
)
3316 if (chain
->num_entries
== 0)
3318 chain
->first_entry
= chain
->last_entry
= NULL
;
3319 return highest_data
;
3322 entry
= bfd_malloc (sizeof * entry
);
3326 chain
->first_entry
= entry
;
3328 for (i
= chain
->num_entries
; i
--;)
3330 bfd_byte
* entry_end
;
3332 entry_end
= rsrc_parse_entry (abfd
, is_name
, entry
, datastart
,
3333 data
, dataend
, rva_bias
, parent
);
3335 highest_data
= max (entry_end
, highest_data
);
3336 if (entry_end
> dataend
)
3341 entry
->next_entry
= bfd_malloc (sizeof * entry
);
3342 entry
= entry
->next_entry
;
3347 entry
->next_entry
= NULL
;
3350 chain
->last_entry
= entry
;
3352 return highest_data
;
3356 rsrc_parse_directory (bfd
* abfd
,
3357 rsrc_directory
* table
,
3358 bfd_byte
* datastart
,
3364 bfd_byte
* highest_data
= data
;
3369 table
->characteristics
= bfd_get_32 (abfd
, data
);
3370 table
->time
= bfd_get_32 (abfd
, data
+ 4);
3371 table
->major
= bfd_get_16 (abfd
, data
+ 8);
3372 table
->minor
= bfd_get_16 (abfd
, data
+ 10);
3373 table
->names
.num_entries
= bfd_get_16 (abfd
, data
+ 12);
3374 table
->ids
.num_entries
= bfd_get_16 (abfd
, data
+ 14);
3375 table
->entry
= entry
;
3379 highest_data
= rsrc_parse_entries (abfd
, & table
->names
, TRUE
, data
,
3380 datastart
, data
, dataend
, rva_bias
, table
);
3381 data
+= table
->names
.num_entries
* 8;
3383 highest_data
= rsrc_parse_entries (abfd
, & table
->ids
, FALSE
, highest_data
,
3384 datastart
, data
, dataend
, rva_bias
, table
);
3385 data
+= table
->ids
.num_entries
* 8;
3387 return max (highest_data
, data
);
3390 typedef struct rsrc_write_data
3393 bfd_byte
* datastart
;
3394 bfd_byte
* next_table
;
3395 bfd_byte
* next_leaf
;
3396 bfd_byte
* next_string
;
3397 bfd_byte
* next_data
;
3402 rsrc_write_string (rsrc_write_data
* data
,
3403 rsrc_string
* string
)
3405 bfd_put_16 (data
->abfd
, string
->len
, data
->next_string
);
3406 memcpy (data
->next_string
+ 2, string
->string
, string
->len
* 2);
3407 data
->next_string
+= (string
->len
+ 1) * 2;
3410 static inline unsigned int
3411 rsrc_compute_rva (rsrc_write_data
* data
,
3414 return (addr
- data
->datastart
) + data
->rva_bias
;
3418 rsrc_write_leaf (rsrc_write_data
* data
,
3421 bfd_put_32 (data
->abfd
, rsrc_compute_rva (data
, data
->next_data
),
3423 bfd_put_32 (data
->abfd
, leaf
->size
, data
->next_leaf
+ 4);
3424 bfd_put_32 (data
->abfd
, leaf
->codepage
, data
->next_leaf
+ 8);
3425 bfd_put_32 (data
->abfd
, 0 /*reserved*/, data
->next_leaf
+ 12);
3426 data
->next_leaf
+= 16;
3428 memcpy (data
->next_data
, leaf
->data
, leaf
->size
);
3429 /* An undocumented feature of Windows resources is that each unit
3430 of raw data is 8-byte aligned... */
3431 data
->next_data
+= ((leaf
->size
+ 7) & ~7);
3434 static void rsrc_write_directory (rsrc_write_data
*, rsrc_directory
*);
3437 rsrc_write_entry (rsrc_write_data
* data
,
3443 bfd_put_32 (data
->abfd
,
3444 SetHighBit (data
->next_string
- data
->datastart
),
3446 rsrc_write_string (data
, & entry
->name_id
.name
);
3449 bfd_put_32 (data
->abfd
, entry
->name_id
.id
, where
);
3453 bfd_put_32 (data
->abfd
,
3454 SetHighBit (data
->next_table
- data
->datastart
),
3456 rsrc_write_directory (data
, entry
->value
.directory
);
3460 bfd_put_32 (data
->abfd
, data
->next_leaf
- data
->datastart
, where
+ 4);
3461 rsrc_write_leaf (data
, entry
->value
.leaf
);
3466 rsrc_compute_region_sizes (rsrc_directory
* dir
)
3468 struct rsrc_entry
* entry
;
3473 sizeof_tables_and_entries
+= 16;
3475 for (entry
= dir
->names
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3477 sizeof_tables_and_entries
+= 8;
3479 sizeof_strings
+= (entry
->name_id
.name
.len
+ 1) * 2;
3482 rsrc_compute_region_sizes (entry
->value
.directory
);
3484 sizeof_leaves
+= 16;
3487 for (entry
= dir
->ids
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3489 sizeof_tables_and_entries
+= 8;
3492 rsrc_compute_region_sizes (entry
->value
.directory
);
3494 sizeof_leaves
+= 16;
3499 rsrc_write_directory (rsrc_write_data
* data
,
3500 rsrc_directory
* dir
)
3504 bfd_byte
* next_entry
;
3507 bfd_put_32 (data
->abfd
, dir
->characteristics
, data
->next_table
);
3508 bfd_put_32 (data
->abfd
, 0 /*dir->time*/, data
->next_table
+ 4);
3509 bfd_put_16 (data
->abfd
, dir
->major
, data
->next_table
+ 8);
3510 bfd_put_16 (data
->abfd
, dir
->minor
, data
->next_table
+ 10);
3511 bfd_put_16 (data
->abfd
, dir
->names
.num_entries
, data
->next_table
+ 12);
3512 bfd_put_16 (data
->abfd
, dir
->ids
.num_entries
, data
->next_table
+ 14);
3514 /* Compute where the entries and the next table will be placed. */
3515 next_entry
= data
->next_table
+ 16;
3516 data
->next_table
= next_entry
+ (dir
->names
.num_entries
* 8)
3517 + (dir
->ids
.num_entries
* 8);
3518 nt
= data
->next_table
;
3520 /* Write the entries. */
3521 for (i
= dir
->names
.num_entries
, entry
= dir
->names
.first_entry
;
3522 i
> 0 && entry
!= NULL
;
3523 i
--, entry
= entry
->next_entry
)
3525 BFD_ASSERT (entry
->is_name
);
3526 rsrc_write_entry (data
, next_entry
, entry
);
3529 BFD_ASSERT (i
== 0);
3530 BFD_ASSERT (entry
== NULL
);
3532 for (i
= dir
->ids
.num_entries
, entry
= dir
->ids
.first_entry
;
3533 i
> 0 && entry
!= NULL
;
3534 i
--, entry
= entry
->next_entry
)
3536 BFD_ASSERT (! entry
->is_name
);
3537 rsrc_write_entry (data
, next_entry
, entry
);
3540 BFD_ASSERT (i
== 0);
3541 BFD_ASSERT (entry
== NULL
);
3542 BFD_ASSERT (nt
== next_entry
);
3545 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3546 /* Return the length (number of units) of the first character in S,
3547 putting its 'ucs4_t' representation in *PUC. */
3550 #if defined HAVE_WCTYPE_H
3551 u16_mbtouc (wint_t * puc
, const unsigned short * s
, unsigned int n
)
3553 u16_mbtouc (wchar_t * puc
, const unsigned short * s
, unsigned int n
)
3556 unsigned short c
= * s
;
3558 if (c
< 0xd800 || c
>= 0xe000)
3568 if (s
[1] >= 0xdc00 && s
[1] < 0xe000)
3570 *puc
= 0x10000 + ((c
- 0xd800) << 10) + (s
[1] - 0xdc00);
3576 /* Incomplete multibyte character. */
3582 /* Invalid multibyte character. */
3586 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3588 /* Perform a comparison of two entries. */
3590 rsrc_cmp (bfd_boolean is_name
, rsrc_entry
* a
, rsrc_entry
* b
)
3599 return a
->name_id
.id
- b
->name_id
.id
;
3601 /* We have to perform a case insenstive, unicode string comparison... */
3602 astring
= a
->name_id
.name
.string
;
3603 alen
= a
->name_id
.name
.len
;
3604 bstring
= b
->name_id
.name
.string
;
3605 blen
= b
->name_id
.name
.len
;
3607 #if defined __CYGWIN__ || defined __MINGW32__
3608 /* Under Windows hosts (both Cygwin and Mingw types),
3609 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3610 function however goes by different names in the two environments... */
3614 #define rscpcmp wcsncasecmp
3617 #define rscpcmp wcsnicmp
3620 res
= rscpcmp ((const wchar_t *) astring
, (const wchar_t *) bstring
,
3623 #elif defined HAVE_WCHAR_H
3628 for (i
= min (alen
, blen
); i
--; astring
+= 2, bstring
+= 2)
3630 #if defined HAVE_WCTYPE_H
3638 /* Convert UTF-16 unicode characters into wchar_t characters
3639 so that we can then perform a case insensitive comparison. */
3640 unsigned int Alen
= u16_mbtouc (& awc
, (const unsigned short *) astring
, 2);
3641 unsigned int Blen
= u16_mbtouc (& bwc
, (const unsigned short *) bstring
, 2);
3646 #ifdef HAVE_WCTYPE_H
3647 awc
= towlower (awc
);
3648 bwc
= towlower (bwc
);
3652 res
= wcsncasecmp (& awc
, & bwc
, 1);
3659 /* Do the best we can - a case sensitive, untranslated comparison. */
3660 res
= memcmp (astring
, bstring
, min (alen
, blen
) * 2);
3670 rsrc_print_name (char * buffer
, rsrc_string string
)
3673 bfd_byte
* name
= string
.string
;
3675 for (i
= string
.len
; i
--; name
+= 2)
3676 sprintf (buffer
+ strlen (buffer
), "%.1s", name
);
3680 rsrc_resource_name (rsrc_entry
* entry
, rsrc_directory
* dir
)
3682 static char buffer
[256];
3683 bfd_boolean is_string
= FALSE
;
3687 if (dir
!= NULL
&& dir
->entry
!= NULL
&& dir
->entry
->parent
!= NULL
3688 && dir
->entry
->parent
->entry
!= NULL
)
3690 strcpy (buffer
, "type: ");
3691 if (dir
->entry
->parent
->entry
->is_name
)
3692 rsrc_print_name (buffer
+ strlen (buffer
),
3693 dir
->entry
->parent
->entry
->name_id
.name
);
3696 unsigned int id
= dir
->entry
->parent
->entry
->name_id
.id
;
3698 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3701 case 1: strcat (buffer
, " (CURSOR)"); break;
3702 case 2: strcat (buffer
, " (BITMAP)"); break;
3703 case 3: strcat (buffer
, " (ICON)"); break;
3704 case 4: strcat (buffer
, " (MENU)"); break;
3705 case 5: strcat (buffer
, " (DIALOG)"); break;
3706 case 6: strcat (buffer
, " (STRING)"); is_string
= TRUE
; break;
3707 case 7: strcat (buffer
, " (FONTDIR)"); break;
3708 case 8: strcat (buffer
, " (FONT)"); break;
3709 case 9: strcat (buffer
, " (ACCELERATOR)"); break;
3710 case 10: strcat (buffer
, " (RCDATA)"); break;
3711 case 11: strcat (buffer
, " (MESSAGETABLE)"); break;
3712 case 12: strcat (buffer
, " (GROUP_CURSOR)"); break;
3713 case 14: strcat (buffer
, " (GROUP_ICON)"); break;
3714 case 16: strcat (buffer
, " (VERSION)"); break;
3715 case 17: strcat (buffer
, " (DLGINCLUDE)"); break;
3716 case 19: strcat (buffer
, " (PLUGPLAY)"); break;
3717 case 20: strcat (buffer
, " (VXD)"); break;
3718 case 21: strcat (buffer
, " (ANICURSOR)"); break;
3719 case 22: strcat (buffer
, " (ANIICON)"); break;
3720 case 23: strcat (buffer
, " (HTML)"); break;
3721 case 24: strcat (buffer
, " (MANIFEST)"); break;
3722 case 240: strcat (buffer
, " (DLGINIT)"); break;
3723 case 241: strcat (buffer
, " (TOOLBAR)"); break;
3728 if (dir
!= NULL
&& dir
->entry
!= NULL
)
3730 strcat (buffer
, " name: ");
3731 if (dir
->entry
->is_name
)
3732 rsrc_print_name (buffer
+ strlen (buffer
), dir
->entry
->name_id
.name
);
3735 unsigned int id
= dir
->entry
->name_id
.id
;
3737 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3740 sprintf (buffer
+ strlen (buffer
), " (resource id range: %d - %d)",
3741 (id
- 1) << 4, (id
<< 4) - 1);
3747 strcat (buffer
, " lang: ");
3750 rsrc_print_name (buffer
+ strlen (buffer
), entry
->name_id
.name
);
3752 sprintf (buffer
+ strlen (buffer
), "%x", entry
->name_id
.id
);
3758 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3759 their ID is stored in the NAME entry. The bottom four bits are used as
3760 an index into unicode string table that makes up the data of the leaf.
3761 So identical type-name-lang string resources may not actually be
3764 This function is called when we have detected two string resources with
3765 match top-28-bit IDs. We have to scan the string tables inside the leaves
3766 and discover if there are any real collisions. If there are then we report
3767 them and return FALSE. Otherwise we copy any strings from B into A and
3768 then return TRUE. */
3771 rsrc_merge_string_entries (rsrc_entry
* a ATTRIBUTE_UNUSED
,
3772 rsrc_entry
* b ATTRIBUTE_UNUSED
)
3774 unsigned int copy_needed
= 0;
3778 bfd_byte
* new_data
;
3781 /* Step one: Find out what we have to do. */
3782 BFD_ASSERT (! a
->is_dir
);
3783 astring
= a
->value
.leaf
->data
;
3785 BFD_ASSERT (! b
->is_dir
);
3786 bstring
= b
->value
.leaf
->data
;
3788 for (i
= 0; i
< 16; i
++)
3790 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3791 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3795 copy_needed
+= blen
* 2;
3799 else if (alen
!= blen
)
3800 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3802 /* alen == blen != 0. We might have two identical strings. If so we
3803 can ignore the second one. There is no need for wchar_t vs UTF-16
3804 theatrics here - we are only interested in (case sensitive) equality. */
3805 else if (memcmp (astring
+ 2, bstring
+ 2, alen
* 2) != 0)
3808 astring
+= (alen
+ 1) * 2;
3809 bstring
+= (blen
+ 1) * 2;
3814 if (a
->parent
!= NULL
3815 && a
->parent
->entry
!= NULL
3816 && !a
->parent
->entry
->is_name
)
3817 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3818 ((a
->parent
->entry
->name_id
.id
- 1) << 4) + i
);
3822 if (copy_needed
== 0)
3825 /* If we reach here then A and B must both have non-colliding strings.
3826 (We never get string resources with fully empty string tables).
3827 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3829 new_data
= bfd_malloc (a
->value
.leaf
->size
+ copy_needed
);
3830 if (new_data
== NULL
)
3834 astring
= a
->value
.leaf
->data
;
3835 bstring
= b
->value
.leaf
->data
;
3837 for (i
= 0; i
< 16; i
++)
3839 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3840 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3844 memcpy (nstring
, astring
, (alen
+ 1) * 2);
3845 nstring
+= (alen
+ 1) * 2;
3849 memcpy (nstring
, bstring
, (blen
+ 1) * 2);
3850 nstring
+= (blen
+ 1) * 2;
3858 astring
+= (alen
+ 1) * 2;
3859 bstring
+= (blen
+ 1) * 2;
3862 BFD_ASSERT (nstring
- new_data
== (signed) (a
->value
.leaf
->size
+ copy_needed
));
3864 free (a
->value
.leaf
->data
);
3865 a
->value
.leaf
->data
= new_data
;
3866 a
->value
.leaf
->size
+= copy_needed
;
3871 static void rsrc_merge (rsrc_entry
*, rsrc_entry
*);
3873 /* Sort the entries in given part of the directory.
3874 We use an old fashioned bubble sort because we are dealing
3875 with lists and we want to handle matches specially. */
3878 rsrc_sort_entries (rsrc_dir_chain
* chain
,
3879 bfd_boolean is_name
,
3880 rsrc_directory
* dir
)
3884 rsrc_entry
** points_to_entry
;
3885 bfd_boolean swapped
;
3887 if (chain
->num_entries
< 2)
3893 points_to_entry
= & chain
->first_entry
;
3894 entry
= * points_to_entry
;
3895 next
= entry
->next_entry
;
3899 signed int cmp
= rsrc_cmp (is_name
, entry
, next
);
3903 entry
->next_entry
= next
->next_entry
;
3904 next
->next_entry
= entry
;
3905 * points_to_entry
= next
;
3906 points_to_entry
= & next
->next_entry
;
3907 next
= entry
->next_entry
;
3912 if (entry
->is_dir
&& next
->is_dir
)
3914 /* When we encounter identical directory entries we have to
3915 merge them together. The exception to this rule is for
3916 resource manifests - there can only be one of these,
3917 even if they differ in language. Zero-language manifests
3918 are assumed to be default manifests (provided by the
3919 Cygwin/MinGW build system) and these can be silently dropped,
3920 unless that would reduce the number of manifests to zero.
3921 There should only ever be one non-zero lang manifest -
3922 if there are more it is an error. A non-zero lang
3923 manifest takes precedence over a default manifest. */
3925 && entry
->name_id
.id
== 1
3927 && dir
->entry
!= NULL
3928 && !dir
->entry
->is_name
3929 && dir
->entry
->name_id
.id
== 0x18)
3931 if (next
->value
.directory
->names
.num_entries
== 0
3932 && next
->value
.directory
->ids
.num_entries
== 1
3933 && !next
->value
.directory
->ids
.first_entry
->is_name
3934 && next
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3935 /* Fall through so that NEXT is dropped. */
3937 else if (entry
->value
.directory
->names
.num_entries
== 0
3938 && entry
->value
.directory
->ids
.num_entries
== 1
3939 && !entry
->value
.directory
->ids
.first_entry
->is_name
3940 && entry
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3942 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
3943 entry
->next_entry
= next
->next_entry
;
3944 next
->next_entry
= entry
;
3945 * points_to_entry
= next
;
3946 points_to_entry
= & next
->next_entry
;
3947 next
= entry
->next_entry
;
3952 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3953 bfd_set_error (bfd_error_file_truncated
);
3957 /* Unhook NEXT from the chain. */
3958 /* FIXME: memory loss here. */
3959 entry
->next_entry
= next
->next_entry
;
3960 chain
->num_entries
--;
3961 if (chain
->num_entries
< 2)
3963 next
= next
->next_entry
;
3966 rsrc_merge (entry
, next
);
3968 else if (entry
->is_dir
!= next
->is_dir
)
3970 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
3971 bfd_set_error (bfd_error_file_truncated
);
3976 /* Otherwise with identical leaves we issue an error
3977 message - because there should never be duplicates.
3978 The exception is Type 18/Name 1/Lang 0 which is the
3979 defaul manifest - this can just be dropped. */
3981 && entry
->name_id
.id
== 0
3983 && dir
->entry
!= NULL
3984 && !dir
->entry
->is_name
3985 && dir
->entry
->name_id
.id
== 1
3986 && dir
->entry
->parent
!= NULL
3987 && dir
->entry
->parent
->entry
!= NULL
3988 && !dir
->entry
->parent
->entry
->is_name
3989 && dir
->entry
->parent
->entry
->name_id
.id
== 0x18 /* RT_MANIFEST */)
3991 else if (dir
!= NULL
3992 && dir
->entry
!= NULL
3993 && dir
->entry
->parent
!= NULL
3994 && dir
->entry
->parent
->entry
!= NULL
3995 && !dir
->entry
->parent
->entry
->is_name
3996 && dir
->entry
->parent
->entry
->name_id
.id
== 0x6 /* RT_STRING */)
3998 /* Strings need special handling. */
3999 if (! rsrc_merge_string_entries (entry
, next
))
4001 /* _bfd_error_handler should have been called inside merge_strings. */
4002 bfd_set_error (bfd_error_file_truncated
);
4009 || dir
->entry
== NULL
4010 || dir
->entry
->parent
== NULL
4011 || dir
->entry
->parent
->entry
== NULL
)
4012 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
4014 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
4015 rsrc_resource_name (entry
, dir
));
4016 bfd_set_error (bfd_error_file_truncated
);
4021 /* Unhook NEXT from the chain. */
4022 entry
->next_entry
= next
->next_entry
;
4023 chain
->num_entries
--;
4024 if (chain
->num_entries
< 2)
4026 next
= next
->next_entry
;
4030 points_to_entry
= & entry
->next_entry
;
4032 next
= next
->next_entry
;
4037 chain
->last_entry
= entry
;
4042 /* Attach B's chain onto A. */
4044 rsrc_attach_chain (rsrc_dir_chain
* achain
, rsrc_dir_chain
* bchain
)
4046 if (bchain
->num_entries
== 0)
4049 achain
->num_entries
+= bchain
->num_entries
;
4051 if (achain
->first_entry
== NULL
)
4053 achain
->first_entry
= bchain
->first_entry
;
4054 achain
->last_entry
= bchain
->last_entry
;
4058 achain
->last_entry
->next_entry
= bchain
->first_entry
;
4059 achain
->last_entry
= bchain
->last_entry
;
4062 bchain
->num_entries
= 0;
4063 bchain
->first_entry
= bchain
->last_entry
= NULL
;
4067 rsrc_merge (struct rsrc_entry
* a
, struct rsrc_entry
* b
)
4069 rsrc_directory
* adir
;
4070 rsrc_directory
* bdir
;
4072 BFD_ASSERT (a
->is_dir
);
4073 BFD_ASSERT (b
->is_dir
);
4075 adir
= a
->value
.directory
;
4076 bdir
= b
->value
.directory
;
4078 if (adir
->characteristics
!= bdir
->characteristics
)
4080 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics"));
4081 bfd_set_error (bfd_error_file_truncated
);
4085 if (adir
->major
!= bdir
->major
|| adir
->minor
!= bdir
->minor
)
4087 _bfd_error_handler (_(".rsrc merge failure: differing directory versions"));
4088 bfd_set_error (bfd_error_file_truncated
);
4092 /* Attach B's name chain to A. */
4093 rsrc_attach_chain (& adir
->names
, & bdir
->names
);
4095 /* Attach B's ID chain to A. */
4096 rsrc_attach_chain (& adir
->ids
, & bdir
->ids
);
4098 /* Now sort A's entries. */
4099 rsrc_sort_entries (& adir
->names
, TRUE
, adir
);
4100 rsrc_sort_entries (& adir
->ids
, FALSE
, adir
);
4103 /* Check the .rsrc section. If it contains multiple concatenated
4104 resources then we must merge them properly. Otherwise Windows
4105 will ignore all but the first set. */
4108 rsrc_process_section (bfd
* abfd
,
4109 struct coff_final_link_info
* pfinfo
)
4111 rsrc_directory new_table
;
4117 bfd_byte
* datastart
;
4119 bfd_byte
* new_data
;
4120 unsigned int num_resource_sets
;
4121 rsrc_directory
* type_tables
;
4122 rsrc_write_data write_data
;
4125 unsigned int num_input_rsrc
= 0;
4126 unsigned int max_num_input_rsrc
= 4;
4127 ptrdiff_t * rsrc_sizes
= NULL
;
4129 new_table
.names
.num_entries
= 0;
4130 new_table
.ids
.num_entries
= 0;
4132 sec
= bfd_get_section_by_name (abfd
, ".rsrc");
4133 if (sec
== NULL
|| (size
= sec
->rawsize
) == 0)
4136 pe
= pe_data (abfd
);
4140 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4142 data
= bfd_malloc (size
);
4148 if (! bfd_get_section_contents (abfd
, sec
, data
, 0, size
))
4151 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4152 their lengths. Note - we rely upon the fact that the linker script
4153 does *not* sort the input .rsrc sections, so that the order in the
4154 linkinfo list matches the order in the output .rsrc section.
4156 We need to know the lengths because each input .rsrc section has padding
4157 at the end of a variable amount. (It does not appear to be based upon
4158 the section alignment or the file alignment). We need to skip any
4159 padding bytes when parsing the input .rsrc sections. */
4160 rsrc_sizes
= bfd_malloc (max_num_input_rsrc
* sizeof * rsrc_sizes
);
4161 if (rsrc_sizes
== NULL
)
4164 for (input
= pfinfo
->info
->input_bfds
;
4166 input
= input
->link
.next
)
4168 asection
* rsrc_sec
= bfd_get_section_by_name (input
, ".rsrc");
4170 /* PR 18372 - skip discarded .rsrc sections. */
4171 if (rsrc_sec
!= NULL
&& !discarded_section (rsrc_sec
))
4173 if (num_input_rsrc
== max_num_input_rsrc
)
4175 max_num_input_rsrc
+= 10;
4176 rsrc_sizes
= bfd_realloc (rsrc_sizes
, max_num_input_rsrc
4177 * sizeof * rsrc_sizes
);
4178 if (rsrc_sizes
== NULL
)
4182 BFD_ASSERT (rsrc_sec
->size
> 0);
4183 rsrc_sizes
[num_input_rsrc
++] = rsrc_sec
->size
;
4187 if (num_input_rsrc
< 2)
4190 /* Step one: Walk the section, computing the size of the tables,
4191 leaves and data and decide if we need to do anything. */
4192 dataend
= data
+ size
;
4193 num_resource_sets
= 0;
4195 while (data
< dataend
)
4197 bfd_byte
* p
= data
;
4199 data
= rsrc_count_directory (abfd
, data
, data
, dataend
, rva_bias
);
4203 /* Corrupted .rsrc section - cannot merge. */
4204 _bfd_error_handler (_("%pB: .rsrc merge failure: corrupt .rsrc section"),
4206 bfd_set_error (bfd_error_file_truncated
);
4210 if ((data
- p
) > rsrc_sizes
[num_resource_sets
])
4212 _bfd_error_handler (_("%pB: .rsrc merge failure: unexpected .rsrc size"),
4214 bfd_set_error (bfd_error_file_truncated
);
4217 /* FIXME: Should we add a check for "data - p" being much smaller
4218 than rsrc_sizes[num_resource_sets] ? */
4220 data
= p
+ rsrc_sizes
[num_resource_sets
];
4221 rva_bias
+= data
- p
;
4222 ++ num_resource_sets
;
4224 BFD_ASSERT (num_resource_sets
== num_input_rsrc
);
4226 /* Step two: Walk the data again, building trees of the resources. */
4228 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4230 type_tables
= bfd_malloc (num_resource_sets
* sizeof * type_tables
);
4231 if (type_tables
== NULL
)
4235 while (data
< dataend
)
4237 bfd_byte
* p
= data
;
4239 (void) rsrc_parse_directory (abfd
, type_tables
+ indx
, data
, data
,
4240 dataend
, rva_bias
, NULL
);
4241 data
= p
+ rsrc_sizes
[indx
];
4242 rva_bias
+= data
- p
;
4245 BFD_ASSERT (indx
== num_resource_sets
);
4247 /* Step three: Merge the top level tables (there can be only one).
4249 We must ensure that the merged entries are in ascending order.
4251 We also thread the top level table entries from the old tree onto
4252 the new table, so that they can be pulled off later. */
4254 /* FIXME: Should we verify that all type tables are the same ? */
4255 new_table
.characteristics
= type_tables
[0].characteristics
;
4256 new_table
.time
= type_tables
[0].time
;
4257 new_table
.major
= type_tables
[0].major
;
4258 new_table
.minor
= type_tables
[0].minor
;
4260 /* Chain the NAME entries onto the table. */
4261 new_table
.names
.first_entry
= NULL
;
4262 new_table
.names
.last_entry
= NULL
;
4264 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4265 rsrc_attach_chain (& new_table
.names
, & type_tables
[indx
].names
);
4267 rsrc_sort_entries (& new_table
.names
, TRUE
, & new_table
);
4269 /* Chain the ID entries onto the table. */
4270 new_table
.ids
.first_entry
= NULL
;
4271 new_table
.ids
.last_entry
= NULL
;
4273 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4274 rsrc_attach_chain (& new_table
.ids
, & type_tables
[indx
].ids
);
4276 rsrc_sort_entries (& new_table
.ids
, FALSE
, & new_table
);
4278 /* Step four: Create new contents for the .rsrc section. */
4279 /* Step four point one: Compute the size of each region of the .rsrc section.
4280 We do this now, rather than earlier, as the merging above may have dropped
4282 sizeof_leaves
= sizeof_strings
= sizeof_tables_and_entries
= 0;
4283 rsrc_compute_region_sizes (& new_table
);
4284 /* We increment sizeof_strings to make sure that resource data
4285 starts on an 8-byte boundary. FIXME: Is this correct ? */
4286 sizeof_strings
= (sizeof_strings
+ 7) & ~ 7;
4288 new_data
= bfd_zalloc (abfd
, size
);
4289 if (new_data
== NULL
)
4292 write_data
.abfd
= abfd
;
4293 write_data
.datastart
= new_data
;
4294 write_data
.next_table
= new_data
;
4295 write_data
.next_leaf
= new_data
+ sizeof_tables_and_entries
;
4296 write_data
.next_string
= write_data
.next_leaf
+ sizeof_leaves
;
4297 write_data
.next_data
= write_data
.next_string
+ sizeof_strings
;
4298 write_data
.rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4300 rsrc_write_directory (& write_data
, & new_table
);
4302 /* Step five: Replace the old contents with the new.
4303 We don't recompute the size as it's too late here to shrink section.
4304 See PR ld/20193 for more details. */
4305 bfd_set_section_contents (pfinfo
->output_bfd
, sec
, new_data
, 0, size
);
4306 sec
->size
= sec
->rawsize
= size
;
4309 /* Step six: Free all the memory that we have used. */
4310 /* FIXME: Free the resource tree, if we have one. */
4315 /* Handle the .idata section and other things that need symbol table
4319 _bfd_XXi_final_link_postscript (bfd
* abfd
, struct coff_final_link_info
*pfinfo
)
4321 struct coff_link_hash_entry
*h1
;
4322 struct bfd_link_info
*info
= pfinfo
->info
;
4323 bfd_boolean result
= TRUE
;
4325 /* There are a few fields that need to be filled in now while we
4326 have symbol table access.
4328 The .idata subsections aren't directly available as sections, but
4329 they are in the symbol table, so get them from there. */
4331 /* The import directory. This is the address of .idata$2, with size
4332 of .idata$2 + .idata$3. */
4333 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4334 ".idata$2", FALSE
, FALSE
, TRUE
);
4337 /* PR ld/2729: We cannot rely upon all the output sections having been
4338 created properly, so check before referencing them. Issue a warning
4339 message for any sections tht could not be found. */
4340 if ((h1
->root
.type
== bfd_link_hash_defined
4341 || h1
->root
.type
== bfd_link_hash_defweak
)
4342 && h1
->root
.u
.def
.section
!= NULL
4343 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4344 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
=
4345 (h1
->root
.u
.def
.value
4346 + h1
->root
.u
.def
.section
->output_section
->vma
4347 + h1
->root
.u
.def
.section
->output_offset
);
4351 (_("%pB: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4356 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4357 ".idata$4", FALSE
, FALSE
, TRUE
);
4359 && (h1
->root
.type
== bfd_link_hash_defined
4360 || h1
->root
.type
== bfd_link_hash_defweak
)
4361 && h1
->root
.u
.def
.section
!= NULL
4362 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4363 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].Size
=
4364 ((h1
->root
.u
.def
.value
4365 + h1
->root
.u
.def
.section
->output_section
->vma
4366 + h1
->root
.u
.def
.section
->output_offset
)
4367 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
);
4371 (_("%pB: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4376 /* The import address table. This is the size/address of
4378 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4379 ".idata$5", FALSE
, FALSE
, TRUE
);
4381 && (h1
->root
.type
== bfd_link_hash_defined
4382 || h1
->root
.type
== bfd_link_hash_defweak
)
4383 && h1
->root
.u
.def
.section
!= NULL
4384 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4385 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4386 (h1
->root
.u
.def
.value
4387 + h1
->root
.u
.def
.section
->output_section
->vma
4388 + h1
->root
.u
.def
.section
->output_offset
);
4392 (_("%pB: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4397 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4398 ".idata$6", FALSE
, FALSE
, TRUE
);
4400 && (h1
->root
.type
== bfd_link_hash_defined
4401 || h1
->root
.type
== bfd_link_hash_defweak
)
4402 && h1
->root
.u
.def
.section
!= NULL
4403 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4404 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4405 ((h1
->root
.u
.def
.value
4406 + h1
->root
.u
.def
.section
->output_section
->vma
4407 + h1
->root
.u
.def
.section
->output_offset
)
4408 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
);
4412 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4419 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4420 "__IAT_start__", FALSE
, FALSE
, TRUE
);
4422 && (h1
->root
.type
== bfd_link_hash_defined
4423 || h1
->root
.type
== bfd_link_hash_defweak
)
4424 && h1
->root
.u
.def
.section
!= NULL
4425 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4430 (h1
->root
.u
.def
.value
4431 + h1
->root
.u
.def
.section
->output_section
->vma
4432 + h1
->root
.u
.def
.section
->output_offset
);
4434 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4435 "__IAT_end__", FALSE
, FALSE
, TRUE
);
4437 && (h1
->root
.type
== bfd_link_hash_defined
4438 || h1
->root
.type
== bfd_link_hash_defweak
)
4439 && h1
->root
.u
.def
.section
!= NULL
4440 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4442 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4443 ((h1
->root
.u
.def
.value
4444 + h1
->root
.u
.def
.section
->output_section
->vma
4445 + h1
->root
.u
.def
.section
->output_offset
)
4447 if (pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
!= 0)
4448 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4449 iat_va
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
4454 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4455 " because .idata$6 is missing"), abfd
);
4461 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4462 (bfd_get_symbol_leading_char (abfd
) != 0
4463 ? "__tls_used" : "_tls_used"),
4464 FALSE
, FALSE
, TRUE
);
4467 if ((h1
->root
.type
== bfd_link_hash_defined
4468 || h1
->root
.type
== bfd_link_hash_defweak
)
4469 && h1
->root
.u
.def
.section
!= NULL
4470 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4471 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].VirtualAddress
=
4472 (h1
->root
.u
.def
.value
4473 + h1
->root
.u
.def
.section
->output_section
->vma
4474 + h1
->root
.u
.def
.section
->output_offset
4475 - pe_data (abfd
)->pe_opthdr
.ImageBase
);
4479 (_("%pB: unable to fill in DataDictionary[9] because __tls_used is missing"),
4483 /* According to PECOFF sepcifications by Microsoft version 8.2
4484 the TLS data directory consists of 4 pointers, followed
4485 by two 4-byte integer. This implies that the total size
4486 is different for 32-bit and 64-bit executables. */
4487 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4488 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x18;
4490 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x28;
4494 /* If there is a .pdata section and we have linked pdata finally, we
4495 need to sort the entries ascending. */
4496 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4498 asection
*sec
= bfd_get_section_by_name (abfd
, ".pdata");
4502 bfd_size_type x
= sec
->rawsize
;
4503 bfd_byte
*tmp_data
= NULL
;
4506 tmp_data
= bfd_malloc (x
);
4508 if (tmp_data
!= NULL
)
4510 if (bfd_get_section_contents (abfd
, sec
, tmp_data
, 0, x
))
4514 12, sort_x64_pdata
);
4515 bfd_set_section_contents (pfinfo
->output_bfd
, sec
,
4526 rsrc_process_section (abfd
, pfinfo
);
4528 /* If we couldn't find idata$2, we either have an excessively
4529 trivial program or are in DEEP trouble; we have to assume trivial