1 /* Support for the generic parts of PE/PEI; the common executable parts.
2 Copyright (C) 1995-2019 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)
109 /* FIXME: This file has various tests of POWERPC_LE_PE. Those tests
110 worked when the code was in peicode.h, but no longer work now that
111 the code is in peigen.c. PowerPC NT is said to be dead. If
112 anybody wants to revive the code, you will have to figure out how
113 to handle those issues. */
116 _bfd_XXi_swap_sym_in (bfd
* abfd
, void * ext1
, void * in1
)
118 SYMENT
*ext
= (SYMENT
*) ext1
;
119 struct internal_syment
*in
= (struct internal_syment
*) in1
;
121 if (ext
->e
.e_name
[0] == 0)
123 in
->_n
._n_n
._n_zeroes
= 0;
124 in
->_n
._n_n
._n_offset
= H_GET_32 (abfd
, ext
->e
.e
.e_offset
);
127 memcpy (in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
129 in
->n_value
= H_GET_32 (abfd
, ext
->e_value
);
130 in
->n_scnum
= (short) H_GET_16 (abfd
, ext
->e_scnum
);
132 if (sizeof (ext
->e_type
) == 2)
133 in
->n_type
= H_GET_16 (abfd
, ext
->e_type
);
135 in
->n_type
= H_GET_32 (abfd
, ext
->e_type
);
137 in
->n_sclass
= H_GET_8 (abfd
, ext
->e_sclass
);
138 in
->n_numaux
= H_GET_8 (abfd
, ext
->e_numaux
);
140 #ifndef STRICT_PE_FORMAT
141 /* This is for Gnu-created DLLs. */
143 /* The section symbols for the .idata$ sections have class 0x68
144 (C_SECTION), which MS documentation indicates is a section
145 symbol. Unfortunately, the value field in the symbol is simply a
146 copy of the .idata section's flags rather than something useful.
147 When these symbols are encountered, change the value to 0 so that
148 they will be handled somewhat correctly in the bfd code. */
149 if (in
->n_sclass
== C_SECTION
)
151 char namebuf
[SYMNMLEN
+ 1];
152 const char *name
= NULL
;
156 /* Create synthetic empty sections as needed. DJ */
157 if (in
->n_scnum
== 0)
161 name
= _bfd_coff_internal_syment_name (abfd
, in
, namebuf
);
164 _bfd_error_handler (_("%pB: unable to find name for empty section"),
166 bfd_set_error (bfd_error_invalid_target
);
170 sec
= bfd_get_section_by_name (abfd
, name
);
172 in
->n_scnum
= sec
->target_index
;
175 if (in
->n_scnum
== 0)
177 int unused_section_number
= 0;
181 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
182 if (unused_section_number
<= sec
->target_index
)
183 unused_section_number
= sec
->target_index
+ 1;
187 name
= (const char *) bfd_alloc (abfd
, strlen (namebuf
) + 1);
190 _bfd_error_handler (_("%pB: out of memory creating name for empty section"),
194 strcpy ((char *) name
, namebuf
);
197 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_DATA
| SEC_LOAD
;
198 sec
= bfd_make_section_anyway_with_flags (abfd
, name
, flags
);
201 _bfd_error_handler (_("%pB: unable to create fake empty section"),
210 sec
->rel_filepos
= 0;
211 sec
->reloc_count
= 0;
212 sec
->line_filepos
= 0;
213 sec
->lineno_count
= 0;
214 sec
->userdata
= NULL
;
216 sec
->alignment_power
= 2;
218 sec
->target_index
= unused_section_number
;
220 in
->n_scnum
= unused_section_number
;
222 in
->n_sclass
= C_STAT
;
226 #ifdef coff_swap_sym_in_hook
227 /* This won't work in peigen.c, but since it's for PPC PE, it's not
229 coff_swap_sym_in_hook (abfd
, ext1
, in1
);
234 abs_finder (bfd
* abfd ATTRIBUTE_UNUSED
, asection
* sec
, void * data
)
236 bfd_vma abs_val
= * (bfd_vma
*) data
;
238 return (sec
->vma
<= abs_val
) && ((sec
->vma
+ (1ULL << 32)) > abs_val
);
242 _bfd_XXi_swap_sym_out (bfd
* abfd
, void * inp
, void * extp
)
244 struct internal_syment
*in
= (struct internal_syment
*) inp
;
245 SYMENT
*ext
= (SYMENT
*) extp
;
247 if (in
->_n
._n_name
[0] == 0)
249 H_PUT_32 (abfd
, 0, ext
->e
.e
.e_zeroes
);
250 H_PUT_32 (abfd
, in
->_n
._n_n
._n_offset
, ext
->e
.e
.e_offset
);
253 memcpy (ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
255 /* The PE32 and PE32+ formats only use 4 bytes to hold the value of a
256 symbol. This is a problem on 64-bit targets where we can generate
257 absolute symbols with values >= 1^32. We try to work around this
258 problem by finding a section whose base address is sufficient to
259 reduce the absolute value to < 1^32, and then transforming the
260 symbol into a section relative symbol. This of course is a hack. */
261 if (sizeof (in
->n_value
) > 4
262 /* The strange computation of the shift amount is here in order to
263 avoid a compile time warning about the comparison always being
264 false. It does not matter if this test fails to work as expected
265 as the worst that can happen is that some absolute symbols are
266 needlessly converted into section relative symbols. */
267 && in
->n_value
> ((1ULL << (sizeof (in
->n_value
) > 4 ? 32 : 31)) - 1)
268 && in
->n_scnum
== N_ABS
)
272 sec
= bfd_sections_find_if (abfd
, abs_finder
, & in
->n_value
);
275 in
->n_value
-= sec
->vma
;
276 in
->n_scnum
= sec
->target_index
;
278 /* else: FIXME: The value is outside the range of any section. This
279 happens for __image_base__ and __ImageBase and maybe some other
280 symbols as well. We should find a way to handle these values. */
283 H_PUT_32 (abfd
, in
->n_value
, ext
->e_value
);
284 H_PUT_16 (abfd
, in
->n_scnum
, ext
->e_scnum
);
286 if (sizeof (ext
->e_type
) == 2)
287 H_PUT_16 (abfd
, in
->n_type
, ext
->e_type
);
289 H_PUT_32 (abfd
, in
->n_type
, ext
->e_type
);
291 H_PUT_8 (abfd
, in
->n_sclass
, ext
->e_sclass
);
292 H_PUT_8 (abfd
, in
->n_numaux
, ext
->e_numaux
);
298 _bfd_XXi_swap_aux_in (bfd
* abfd
,
302 int indx ATTRIBUTE_UNUSED
,
303 int numaux ATTRIBUTE_UNUSED
,
306 AUXENT
*ext
= (AUXENT
*) ext1
;
307 union internal_auxent
*in
= (union internal_auxent
*) in1
;
309 /* PR 17521: Make sure that all fields in the aux structure
311 memset (in
, 0, sizeof * in
);
315 if (ext
->x_file
.x_fname
[0] == 0)
317 in
->x_file
.x_n
.x_zeroes
= 0;
318 in
->x_file
.x_n
.x_offset
= H_GET_32 (abfd
, ext
->x_file
.x_n
.x_offset
);
321 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
329 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN (abfd
, ext
);
330 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC (abfd
, ext
);
331 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO (abfd
, ext
);
332 in
->x_scn
.x_checksum
= H_GET_32 (abfd
, ext
->x_scn
.x_checksum
);
333 in
->x_scn
.x_associated
= H_GET_16 (abfd
, ext
->x_scn
.x_associated
);
334 in
->x_scn
.x_comdat
= H_GET_8 (abfd
, ext
->x_scn
.x_comdat
);
340 in
->x_sym
.x_tagndx
.l
= H_GET_32 (abfd
, ext
->x_sym
.x_tagndx
);
341 in
->x_sym
.x_tvndx
= H_GET_16 (abfd
, ext
->x_sym
.x_tvndx
);
343 if (in_class
== C_BLOCK
|| in_class
== C_FCN
|| ISFCN (type
)
346 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR (abfd
, ext
);
347 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX (abfd
, ext
);
351 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0] =
352 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
353 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1] =
354 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
355 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2] =
356 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
357 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3] =
358 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
363 in
->x_sym
.x_misc
.x_fsize
= H_GET_32 (abfd
, ext
->x_sym
.x_misc
.x_fsize
);
367 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO (abfd
, ext
);
368 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE (abfd
, ext
);
373 _bfd_XXi_swap_aux_out (bfd
* abfd
,
377 int indx ATTRIBUTE_UNUSED
,
378 int numaux ATTRIBUTE_UNUSED
,
381 union internal_auxent
*in
= (union internal_auxent
*) inp
;
382 AUXENT
*ext
= (AUXENT
*) extp
;
384 memset (ext
, 0, AUXESZ
);
389 if (in
->x_file
.x_fname
[0] == 0)
391 H_PUT_32 (abfd
, 0, ext
->x_file
.x_n
.x_zeroes
);
392 H_PUT_32 (abfd
, in
->x_file
.x_n
.x_offset
, ext
->x_file
.x_n
.x_offset
);
395 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
404 PUT_SCN_SCNLEN (abfd
, in
->x_scn
.x_scnlen
, ext
);
405 PUT_SCN_NRELOC (abfd
, in
->x_scn
.x_nreloc
, ext
);
406 PUT_SCN_NLINNO (abfd
, in
->x_scn
.x_nlinno
, ext
);
407 H_PUT_32 (abfd
, in
->x_scn
.x_checksum
, ext
->x_scn
.x_checksum
);
408 H_PUT_16 (abfd
, in
->x_scn
.x_associated
, ext
->x_scn
.x_associated
);
409 H_PUT_8 (abfd
, in
->x_scn
.x_comdat
, ext
->x_scn
.x_comdat
);
415 H_PUT_32 (abfd
, in
->x_sym
.x_tagndx
.l
, ext
->x_sym
.x_tagndx
);
416 H_PUT_16 (abfd
, in
->x_sym
.x_tvndx
, ext
->x_sym
.x_tvndx
);
418 if (in_class
== C_BLOCK
|| in_class
== C_FCN
|| ISFCN (type
)
421 PUT_FCN_LNNOPTR (abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
422 PUT_FCN_ENDNDX (abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
426 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0],
427 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
428 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1],
429 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
430 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2],
431 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
432 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3],
433 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
437 H_PUT_32 (abfd
, in
->x_sym
.x_misc
.x_fsize
, ext
->x_sym
.x_misc
.x_fsize
);
440 PUT_LNSZ_LNNO (abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
441 PUT_LNSZ_SIZE (abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
448 _bfd_XXi_swap_lineno_in (bfd
* abfd
, void * ext1
, void * in1
)
450 LINENO
*ext
= (LINENO
*) ext1
;
451 struct internal_lineno
*in
= (struct internal_lineno
*) in1
;
453 in
->l_addr
.l_symndx
= H_GET_32 (abfd
, ext
->l_addr
.l_symndx
);
454 in
->l_lnno
= GET_LINENO_LNNO (abfd
, ext
);
458 _bfd_XXi_swap_lineno_out (bfd
* abfd
, void * inp
, void * outp
)
460 struct internal_lineno
*in
= (struct internal_lineno
*) inp
;
461 struct external_lineno
*ext
= (struct external_lineno
*) outp
;
462 H_PUT_32 (abfd
, in
->l_addr
.l_symndx
, ext
->l_addr
.l_symndx
);
464 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
469 _bfd_XXi_swap_aouthdr_in (bfd
* abfd
,
473 PEAOUTHDR
* src
= (PEAOUTHDR
*) aouthdr_ext1
;
474 AOUTHDR
* aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
475 struct internal_aouthdr
*aouthdr_int
476 = (struct internal_aouthdr
*) aouthdr_int1
;
477 struct internal_extra_pe_aouthdr
*a
= &aouthdr_int
->pe
;
479 aouthdr_int
->magic
= H_GET_16 (abfd
, aouthdr_ext
->magic
);
480 aouthdr_int
->vstamp
= H_GET_16 (abfd
, aouthdr_ext
->vstamp
);
481 aouthdr_int
->tsize
= GET_AOUTHDR_TSIZE (abfd
, aouthdr_ext
->tsize
);
482 aouthdr_int
->dsize
= GET_AOUTHDR_DSIZE (abfd
, aouthdr_ext
->dsize
);
483 aouthdr_int
->bsize
= GET_AOUTHDR_BSIZE (abfd
, aouthdr_ext
->bsize
);
484 aouthdr_int
->entry
= GET_AOUTHDR_ENTRY (abfd
, aouthdr_ext
->entry
);
485 aouthdr_int
->text_start
=
486 GET_AOUTHDR_TEXT_START (abfd
, aouthdr_ext
->text_start
);
488 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
489 /* PE32+ does not have data_start member! */
490 aouthdr_int
->data_start
=
491 GET_AOUTHDR_DATA_START (abfd
, aouthdr_ext
->data_start
);
492 a
->BaseOfData
= aouthdr_int
->data_start
;
495 a
->Magic
= aouthdr_int
->magic
;
496 a
->MajorLinkerVersion
= H_GET_8 (abfd
, aouthdr_ext
->vstamp
);
497 a
->MinorLinkerVersion
= H_GET_8 (abfd
, aouthdr_ext
->vstamp
+ 1);
498 a
->SizeOfCode
= aouthdr_int
->tsize
;
499 a
->SizeOfInitializedData
= aouthdr_int
->dsize
;
500 a
->SizeOfUninitializedData
= aouthdr_int
->bsize
;
501 a
->AddressOfEntryPoint
= aouthdr_int
->entry
;
502 a
->BaseOfCode
= aouthdr_int
->text_start
;
503 a
->ImageBase
= GET_OPTHDR_IMAGE_BASE (abfd
, src
->ImageBase
);
504 a
->SectionAlignment
= H_GET_32 (abfd
, src
->SectionAlignment
);
505 a
->FileAlignment
= H_GET_32 (abfd
, src
->FileAlignment
);
506 a
->MajorOperatingSystemVersion
=
507 H_GET_16 (abfd
, src
->MajorOperatingSystemVersion
);
508 a
->MinorOperatingSystemVersion
=
509 H_GET_16 (abfd
, src
->MinorOperatingSystemVersion
);
510 a
->MajorImageVersion
= H_GET_16 (abfd
, src
->MajorImageVersion
);
511 a
->MinorImageVersion
= H_GET_16 (abfd
, src
->MinorImageVersion
);
512 a
->MajorSubsystemVersion
= H_GET_16 (abfd
, src
->MajorSubsystemVersion
);
513 a
->MinorSubsystemVersion
= H_GET_16 (abfd
, src
->MinorSubsystemVersion
);
514 a
->Reserved1
= H_GET_32 (abfd
, src
->Reserved1
);
515 a
->SizeOfImage
= H_GET_32 (abfd
, src
->SizeOfImage
);
516 a
->SizeOfHeaders
= H_GET_32 (abfd
, src
->SizeOfHeaders
);
517 a
->CheckSum
= H_GET_32 (abfd
, src
->CheckSum
);
518 a
->Subsystem
= H_GET_16 (abfd
, src
->Subsystem
);
519 a
->DllCharacteristics
= H_GET_16 (abfd
, src
->DllCharacteristics
);
520 a
->SizeOfStackReserve
=
521 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd
, src
->SizeOfStackReserve
);
522 a
->SizeOfStackCommit
=
523 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd
, src
->SizeOfStackCommit
);
524 a
->SizeOfHeapReserve
=
525 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd
, src
->SizeOfHeapReserve
);
526 a
->SizeOfHeapCommit
=
527 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd
, src
->SizeOfHeapCommit
);
528 a
->LoaderFlags
= H_GET_32 (abfd
, src
->LoaderFlags
);
529 a
->NumberOfRvaAndSizes
= H_GET_32 (abfd
, src
->NumberOfRvaAndSizes
);
534 /* PR 17512: Corrupt PE binaries can cause seg-faults. */
535 if (a
->NumberOfRvaAndSizes
> IMAGE_NUMBEROF_DIRECTORY_ENTRIES
)
537 /* xgettext:c-format */
539 (_("%pB: aout header specifies an invalid number of"
540 " data-directory entries: %u"), abfd
, a
->NumberOfRvaAndSizes
);
541 bfd_set_error (bfd_error_bad_value
);
543 /* Paranoia: If the number is corrupt, then assume that the
544 actual entries themselves might be corrupt as well. */
545 a
->NumberOfRvaAndSizes
= 0;
548 for (idx
= 0; idx
< a
->NumberOfRvaAndSizes
; idx
++)
550 /* If data directory is empty, rva also should be 0. */
552 H_GET_32 (abfd
, src
->DataDirectory
[idx
][1]);
554 a
->DataDirectory
[idx
].Size
= size
;
557 a
->DataDirectory
[idx
].VirtualAddress
=
558 H_GET_32 (abfd
, src
->DataDirectory
[idx
][0]);
560 a
->DataDirectory
[idx
].VirtualAddress
= 0;
563 while (idx
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
)
565 a
->DataDirectory
[idx
].Size
= 0;
566 a
->DataDirectory
[idx
].VirtualAddress
= 0;
571 if (aouthdr_int
->entry
)
573 aouthdr_int
->entry
+= a
->ImageBase
;
574 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
575 aouthdr_int
->entry
&= 0xffffffff;
579 if (aouthdr_int
->tsize
)
581 aouthdr_int
->text_start
+= a
->ImageBase
;
582 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
583 aouthdr_int
->text_start
&= 0xffffffff;
587 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
588 /* PE32+ does not have data_start member! */
589 if (aouthdr_int
->dsize
)
591 aouthdr_int
->data_start
+= a
->ImageBase
;
592 aouthdr_int
->data_start
&= 0xffffffff;
597 /* These three fields are normally set up by ppc_relocate_section.
598 In the case of reading a file in, we can pick them up from the
600 first_thunk_address
= a
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
;
601 thunk_size
= a
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
;
602 import_table_size
= a
->DataDirectory
[PE_IMPORT_TABLE
].Size
;
606 /* A support function for below. */
609 add_data_entry (bfd
* abfd
,
610 struct internal_extra_pe_aouthdr
*aout
,
615 asection
*sec
= bfd_get_section_by_name (abfd
, name
);
617 /* Add import directory information if it exists. */
619 && (coff_section_data (abfd
, sec
) != NULL
)
620 && (pei_section_data (abfd
, sec
) != NULL
))
622 /* If data directory is empty, rva also should be 0. */
623 int size
= pei_section_data (abfd
, sec
)->virt_size
;
624 aout
->DataDirectory
[idx
].Size
= size
;
628 aout
->DataDirectory
[idx
].VirtualAddress
=
629 (sec
->vma
- base
) & 0xffffffff;
630 sec
->flags
|= SEC_DATA
;
636 _bfd_XXi_swap_aouthdr_out (bfd
* abfd
, void * in
, void * out
)
638 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*) in
;
639 pe_data_type
*pe
= pe_data (abfd
);
640 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
641 PEAOUTHDR
*aouthdr_out
= (PEAOUTHDR
*) out
;
643 IMAGE_DATA_DIRECTORY idata2
, idata5
, tls
;
645 sa
= extra
->SectionAlignment
;
646 fa
= extra
->FileAlignment
;
647 ib
= extra
->ImageBase
;
649 idata2
= pe
->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
];
650 idata5
= pe
->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
];
651 tls
= pe
->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
];
653 if (aouthdr_in
->tsize
)
655 aouthdr_in
->text_start
-= ib
;
656 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
657 aouthdr_in
->text_start
&= 0xffffffff;
661 if (aouthdr_in
->dsize
)
663 aouthdr_in
->data_start
-= ib
;
664 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
665 aouthdr_in
->data_start
&= 0xffffffff;
669 if (aouthdr_in
->entry
)
671 aouthdr_in
->entry
-= ib
;
672 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
673 aouthdr_in
->entry
&= 0xffffffff;
677 #define FA(x) (((x) + fa -1 ) & (- fa))
678 #define SA(x) (((x) + sa -1 ) & (- sa))
680 /* We like to have the sizes aligned. */
681 aouthdr_in
->bsize
= FA (aouthdr_in
->bsize
);
683 extra
->NumberOfRvaAndSizes
= IMAGE_NUMBEROF_DIRECTORY_ENTRIES
;
685 add_data_entry (abfd
, extra
, PE_EXPORT_TABLE
, ".edata", ib
);
686 add_data_entry (abfd
, extra
, PE_RESOURCE_TABLE
, ".rsrc", ib
);
687 add_data_entry (abfd
, extra
, PE_EXCEPTION_TABLE
, ".pdata", ib
);
689 /* In theory we do not need to call add_data_entry for .idata$2 or
690 .idata$5. It will be done in bfd_coff_final_link where all the
691 required information is available. If however, we are not going
692 to perform a final link, eg because we have been invoked by objcopy
693 or strip, then we need to make sure that these Data Directory
694 entries are initialised properly.
696 So - we copy the input values into the output values, and then, if
697 a final link is going to be performed, it can overwrite them. */
698 extra
->DataDirectory
[PE_IMPORT_TABLE
] = idata2
;
699 extra
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
] = idata5
;
700 extra
->DataDirectory
[PE_TLS_TABLE
] = tls
;
702 if (extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
== 0)
703 /* Until other .idata fixes are made (pending patch), the entry for
704 .idata is needed for backwards compatibility. FIXME. */
705 add_data_entry (abfd
, extra
, PE_IMPORT_TABLE
, ".idata", ib
);
707 /* For some reason, the virtual size (which is what's set by
708 add_data_entry) for .reloc is not the same as the size recorded
709 in this slot by MSVC; it doesn't seem to cause problems (so far),
710 but since it's the best we've got, use it. It does do the right
712 if (pe
->has_reloc_section
)
713 add_data_entry (abfd
, extra
, PE_BASE_RELOCATION_TABLE
, ".reloc", ib
);
722 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
724 int rounded
= FA (sec
->size
);
726 /* The first non-zero section filepos is the header size.
727 Sections without contents will have a filepos of 0. */
729 hsize
= sec
->filepos
;
730 if (sec
->flags
& SEC_DATA
)
732 if (sec
->flags
& SEC_CODE
)
734 /* The image size is the total VIRTUAL size (which is what is
735 in the virt_size field). Files have been seen (from MSVC
736 5.0 link.exe) where the file size of the .data segment is
737 quite small compared to the virtual size. Without this
738 fix, strip munges the file.
740 FIXME: We need to handle holes between sections, which may
741 happpen when we covert from another format. We just use
742 the virtual address and virtual size of the last section
743 for the image size. */
744 if (coff_section_data (abfd
, sec
) != NULL
745 && pei_section_data (abfd
, sec
) != NULL
)
746 isize
= (sec
->vma
- extra
->ImageBase
747 + SA (FA (pei_section_data (abfd
, sec
)->virt_size
)));
750 aouthdr_in
->dsize
= dsize
;
751 aouthdr_in
->tsize
= tsize
;
752 extra
->SizeOfHeaders
= hsize
;
753 extra
->SizeOfImage
= isize
;
756 H_PUT_16 (abfd
, aouthdr_in
->magic
, aouthdr_out
->standard
.magic
);
758 /* e.g. 219510000 is linker version 2.19 */
759 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
761 /* This piece of magic sets the "linker version" field to
763 H_PUT_16 (abfd
, (LINKER_VERSION
/ 100 + (LINKER_VERSION
% 100) * 256),
764 aouthdr_out
->standard
.vstamp
);
766 PUT_AOUTHDR_TSIZE (abfd
, aouthdr_in
->tsize
, aouthdr_out
->standard
.tsize
);
767 PUT_AOUTHDR_DSIZE (abfd
, aouthdr_in
->dsize
, aouthdr_out
->standard
.dsize
);
768 PUT_AOUTHDR_BSIZE (abfd
, aouthdr_in
->bsize
, aouthdr_out
->standard
.bsize
);
769 PUT_AOUTHDR_ENTRY (abfd
, aouthdr_in
->entry
, aouthdr_out
->standard
.entry
);
770 PUT_AOUTHDR_TEXT_START (abfd
, aouthdr_in
->text_start
,
771 aouthdr_out
->standard
.text_start
);
773 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
774 /* PE32+ does not have data_start member! */
775 PUT_AOUTHDR_DATA_START (abfd
, aouthdr_in
->data_start
,
776 aouthdr_out
->standard
.data_start
);
779 PUT_OPTHDR_IMAGE_BASE (abfd
, extra
->ImageBase
, aouthdr_out
->ImageBase
);
780 H_PUT_32 (abfd
, extra
->SectionAlignment
, aouthdr_out
->SectionAlignment
);
781 H_PUT_32 (abfd
, extra
->FileAlignment
, aouthdr_out
->FileAlignment
);
782 H_PUT_16 (abfd
, extra
->MajorOperatingSystemVersion
,
783 aouthdr_out
->MajorOperatingSystemVersion
);
784 H_PUT_16 (abfd
, extra
->MinorOperatingSystemVersion
,
785 aouthdr_out
->MinorOperatingSystemVersion
);
786 H_PUT_16 (abfd
, extra
->MajorImageVersion
, aouthdr_out
->MajorImageVersion
);
787 H_PUT_16 (abfd
, extra
->MinorImageVersion
, aouthdr_out
->MinorImageVersion
);
788 H_PUT_16 (abfd
, extra
->MajorSubsystemVersion
,
789 aouthdr_out
->MajorSubsystemVersion
);
790 H_PUT_16 (abfd
, extra
->MinorSubsystemVersion
,
791 aouthdr_out
->MinorSubsystemVersion
);
792 H_PUT_32 (abfd
, extra
->Reserved1
, aouthdr_out
->Reserved1
);
793 H_PUT_32 (abfd
, extra
->SizeOfImage
, aouthdr_out
->SizeOfImage
);
794 H_PUT_32 (abfd
, extra
->SizeOfHeaders
, aouthdr_out
->SizeOfHeaders
);
795 H_PUT_32 (abfd
, extra
->CheckSum
, aouthdr_out
->CheckSum
);
796 H_PUT_16 (abfd
, extra
->Subsystem
, aouthdr_out
->Subsystem
);
797 H_PUT_16 (abfd
, extra
->DllCharacteristics
, aouthdr_out
->DllCharacteristics
);
798 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd
, extra
->SizeOfStackReserve
,
799 aouthdr_out
->SizeOfStackReserve
);
800 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd
, extra
->SizeOfStackCommit
,
801 aouthdr_out
->SizeOfStackCommit
);
802 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd
, extra
->SizeOfHeapReserve
,
803 aouthdr_out
->SizeOfHeapReserve
);
804 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd
, extra
->SizeOfHeapCommit
,
805 aouthdr_out
->SizeOfHeapCommit
);
806 H_PUT_32 (abfd
, extra
->LoaderFlags
, aouthdr_out
->LoaderFlags
);
807 H_PUT_32 (abfd
, extra
->NumberOfRvaAndSizes
,
808 aouthdr_out
->NumberOfRvaAndSizes
);
812 for (idx
= 0; idx
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; idx
++)
814 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].VirtualAddress
,
815 aouthdr_out
->DataDirectory
[idx
][0]);
816 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].Size
,
817 aouthdr_out
->DataDirectory
[idx
][1]);
825 _bfd_XXi_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
828 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
829 struct external_PEI_filehdr
*filehdr_out
= (struct external_PEI_filehdr
*) out
;
831 if (pe_data (abfd
)->has_reloc_section
832 || pe_data (abfd
)->dont_strip_reloc
)
833 filehdr_in
->f_flags
&= ~F_RELFLG
;
835 if (pe_data (abfd
)->dll
)
836 filehdr_in
->f_flags
|= F_DLL
;
838 filehdr_in
->pe
.e_magic
= IMAGE_DOS_SIGNATURE
;
839 filehdr_in
->pe
.e_cblp
= 0x90;
840 filehdr_in
->pe
.e_cp
= 0x3;
841 filehdr_in
->pe
.e_crlc
= 0x0;
842 filehdr_in
->pe
.e_cparhdr
= 0x4;
843 filehdr_in
->pe
.e_minalloc
= 0x0;
844 filehdr_in
->pe
.e_maxalloc
= 0xffff;
845 filehdr_in
->pe
.e_ss
= 0x0;
846 filehdr_in
->pe
.e_sp
= 0xb8;
847 filehdr_in
->pe
.e_csum
= 0x0;
848 filehdr_in
->pe
.e_ip
= 0x0;
849 filehdr_in
->pe
.e_cs
= 0x0;
850 filehdr_in
->pe
.e_lfarlc
= 0x40;
851 filehdr_in
->pe
.e_ovno
= 0x0;
853 for (idx
= 0; idx
< 4; idx
++)
854 filehdr_in
->pe
.e_res
[idx
] = 0x0;
856 filehdr_in
->pe
.e_oemid
= 0x0;
857 filehdr_in
->pe
.e_oeminfo
= 0x0;
859 for (idx
= 0; idx
< 10; idx
++)
860 filehdr_in
->pe
.e_res2
[idx
] = 0x0;
862 filehdr_in
->pe
.e_lfanew
= 0x80;
864 /* This next collection of data are mostly just characters. It
865 appears to be constant within the headers put on NT exes. */
866 filehdr_in
->pe
.dos_message
[0] = 0x0eba1f0e;
867 filehdr_in
->pe
.dos_message
[1] = 0xcd09b400;
868 filehdr_in
->pe
.dos_message
[2] = 0x4c01b821;
869 filehdr_in
->pe
.dos_message
[3] = 0x685421cd;
870 filehdr_in
->pe
.dos_message
[4] = 0x70207369;
871 filehdr_in
->pe
.dos_message
[5] = 0x72676f72;
872 filehdr_in
->pe
.dos_message
[6] = 0x63206d61;
873 filehdr_in
->pe
.dos_message
[7] = 0x6f6e6e61;
874 filehdr_in
->pe
.dos_message
[8] = 0x65622074;
875 filehdr_in
->pe
.dos_message
[9] = 0x6e757220;
876 filehdr_in
->pe
.dos_message
[10] = 0x206e6920;
877 filehdr_in
->pe
.dos_message
[11] = 0x20534f44;
878 filehdr_in
->pe
.dos_message
[12] = 0x65646f6d;
879 filehdr_in
->pe
.dos_message
[13] = 0x0a0d0d2e;
880 filehdr_in
->pe
.dos_message
[14] = 0x24;
881 filehdr_in
->pe
.dos_message
[15] = 0x0;
882 filehdr_in
->pe
.nt_signature
= IMAGE_NT_SIGNATURE
;
884 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
885 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
887 /* Use a real timestamp by default, unless the no-insert-timestamp
888 option was chosen. */
889 if ((pe_data (abfd
)->insert_timestamp
))
890 H_PUT_32 (abfd
, time (0), filehdr_out
->f_timdat
);
892 H_PUT_32 (abfd
, 0, filehdr_out
->f_timdat
);
894 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
895 filehdr_out
->f_symptr
);
896 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
897 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
898 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
900 /* Put in extra dos header stuff. This data remains essentially
901 constant, it just has to be tacked on to the beginning of all exes
903 H_PUT_16 (abfd
, filehdr_in
->pe
.e_magic
, filehdr_out
->e_magic
);
904 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cblp
, filehdr_out
->e_cblp
);
905 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cp
, filehdr_out
->e_cp
);
906 H_PUT_16 (abfd
, filehdr_in
->pe
.e_crlc
, filehdr_out
->e_crlc
);
907 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cparhdr
, filehdr_out
->e_cparhdr
);
908 H_PUT_16 (abfd
, filehdr_in
->pe
.e_minalloc
, filehdr_out
->e_minalloc
);
909 H_PUT_16 (abfd
, filehdr_in
->pe
.e_maxalloc
, filehdr_out
->e_maxalloc
);
910 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ss
, filehdr_out
->e_ss
);
911 H_PUT_16 (abfd
, filehdr_in
->pe
.e_sp
, filehdr_out
->e_sp
);
912 H_PUT_16 (abfd
, filehdr_in
->pe
.e_csum
, filehdr_out
->e_csum
);
913 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ip
, filehdr_out
->e_ip
);
914 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cs
, filehdr_out
->e_cs
);
915 H_PUT_16 (abfd
, filehdr_in
->pe
.e_lfarlc
, filehdr_out
->e_lfarlc
);
916 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ovno
, filehdr_out
->e_ovno
);
918 for (idx
= 0; idx
< 4; idx
++)
919 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res
[idx
], filehdr_out
->e_res
[idx
]);
921 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oemid
, filehdr_out
->e_oemid
);
922 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oeminfo
, filehdr_out
->e_oeminfo
);
924 for (idx
= 0; idx
< 10; idx
++)
925 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res2
[idx
], filehdr_out
->e_res2
[idx
]);
927 H_PUT_32 (abfd
, filehdr_in
->pe
.e_lfanew
, filehdr_out
->e_lfanew
);
929 for (idx
= 0; idx
< 16; idx
++)
930 H_PUT_32 (abfd
, filehdr_in
->pe
.dos_message
[idx
],
931 filehdr_out
->dos_message
[idx
]);
933 /* Also put in the NT signature. */
934 H_PUT_32 (abfd
, filehdr_in
->pe
.nt_signature
, filehdr_out
->nt_signature
);
940 _bfd_XX_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
942 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
943 FILHDR
*filehdr_out
= (FILHDR
*) out
;
945 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
946 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
947 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->f_timdat
);
948 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
, filehdr_out
->f_symptr
);
949 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
950 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
951 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
957 _bfd_XXi_swap_scnhdr_out (bfd
* abfd
, void * in
, void * out
)
959 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*) in
;
960 SCNHDR
*scnhdr_ext
= (SCNHDR
*) out
;
961 unsigned int ret
= SCNHSZ
;
965 memcpy (scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof (scnhdr_int
->s_name
));
967 PUT_SCNHDR_VADDR (abfd
,
968 ((scnhdr_int
->s_vaddr
969 - pe_data (abfd
)->pe_opthdr
.ImageBase
)
971 scnhdr_ext
->s_vaddr
);
973 /* NT wants the size data to be rounded up to the next
974 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
976 if ((scnhdr_int
->s_flags
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
) != 0)
978 if (bfd_pei_p (abfd
))
980 ps
= scnhdr_int
->s_size
;
986 ss
= scnhdr_int
->s_size
;
991 if (bfd_pei_p (abfd
))
992 ps
= scnhdr_int
->s_paddr
;
996 ss
= scnhdr_int
->s_size
;
999 PUT_SCNHDR_SIZE (abfd
, ss
,
1000 scnhdr_ext
->s_size
);
1002 /* s_paddr in PE is really the virtual size. */
1003 PUT_SCNHDR_PADDR (abfd
, ps
, scnhdr_ext
->s_paddr
);
1005 PUT_SCNHDR_SCNPTR (abfd
, scnhdr_int
->s_scnptr
,
1006 scnhdr_ext
->s_scnptr
);
1007 PUT_SCNHDR_RELPTR (abfd
, scnhdr_int
->s_relptr
,
1008 scnhdr_ext
->s_relptr
);
1009 PUT_SCNHDR_LNNOPTR (abfd
, scnhdr_int
->s_lnnoptr
,
1010 scnhdr_ext
->s_lnnoptr
);
1013 /* Extra flags must be set when dealing with PE. All sections should also
1014 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
1015 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
1016 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
1017 (this is especially important when dealing with the .idata section since
1018 the addresses for routines from .dlls must be overwritten). If .reloc
1019 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
1020 (0x02000000). Also, the resource data should also be read and
1023 /* FIXME: Alignment is also encoded in this field, at least on PPC and
1024 ARM-WINCE. Although - how do we get the original alignment field
1029 char section_name
[SCNNMLEN
];
1030 unsigned long must_have
;
1032 pe_required_section_flags
;
1034 pe_required_section_flags known_sections
[] =
1036 { ".arch", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
| IMAGE_SCN_ALIGN_8BYTES
},
1037 { ".bss", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1038 { ".data", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1039 { ".edata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1040 { ".idata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1041 { ".pdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1042 { ".rdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1043 { ".reloc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
},
1044 { ".rsrc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1045 { ".text" , IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_CODE
| IMAGE_SCN_MEM_EXECUTE
},
1046 { ".tls", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1047 { ".xdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1050 pe_required_section_flags
* p
;
1052 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1053 we know exactly what this specific section wants so we remove it
1054 and then allow the must_have field to add it back in if necessary.
1055 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1056 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
1057 by ld --enable-auto-import (if auto-import is actually needed),
1058 by ld --omagic, or by obcopy --writable-text. */
1060 for (p
= known_sections
;
1061 p
< known_sections
+ ARRAY_SIZE (known_sections
);
1063 if (memcmp (scnhdr_int
->s_name
, p
->section_name
, SCNNMLEN
) == 0)
1065 if (memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text")
1066 || (bfd_get_file_flags (abfd
) & WP_TEXT
))
1067 scnhdr_int
->s_flags
&= ~IMAGE_SCN_MEM_WRITE
;
1068 scnhdr_int
->s_flags
|= p
->must_have
;
1072 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1075 if (coff_data (abfd
)->link_info
1076 && ! bfd_link_relocatable (coff_data (abfd
)->link_info
)
1077 && ! bfd_link_pic (coff_data (abfd
)->link_info
)
1078 && memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text") == 0)
1080 /* By inference from looking at MS output, the 32 bit field
1081 which is the combination of the number_of_relocs and
1082 number_of_linenos is used for the line number count in
1083 executables. A 16-bit field won't do for cc1. The MS
1084 document says that the number of relocs is zero for
1085 executables, but the 17-th bit has been observed to be there.
1086 Overflow is not an issue: a 4G-line program will overflow a
1087 bunch of other fields long before this! */
1088 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
& 0xffff), scnhdr_ext
->s_nlnno
);
1089 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
>> 16), scnhdr_ext
->s_nreloc
);
1093 if (scnhdr_int
->s_nlnno
<= 0xffff)
1094 H_PUT_16 (abfd
, scnhdr_int
->s_nlnno
, scnhdr_ext
->s_nlnno
);
1097 /* xgettext:c-format */
1098 _bfd_error_handler (_("%pB: line number overflow: 0x%lx > 0xffff"),
1099 abfd
, scnhdr_int
->s_nlnno
);
1100 bfd_set_error (bfd_error_file_truncated
);
1101 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nlnno
);
1105 /* Although we could encode 0xffff relocs here, we do not, to be
1106 consistent with other parts of bfd. Also it lets us warn, as
1107 we should never see 0xffff here w/o having the overflow flag
1109 if (scnhdr_int
->s_nreloc
< 0xffff)
1110 H_PUT_16 (abfd
, scnhdr_int
->s_nreloc
, scnhdr_ext
->s_nreloc
);
1113 /* PE can deal with large #s of relocs, but not here. */
1114 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nreloc
);
1115 scnhdr_int
->s_flags
|= IMAGE_SCN_LNK_NRELOC_OVFL
;
1116 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1123 _bfd_XXi_swap_debugdir_in (bfd
* abfd
, void * ext1
, void * in1
)
1125 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) ext1
;
1126 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) in1
;
1128 in
->Characteristics
= H_GET_32(abfd
, ext
->Characteristics
);
1129 in
->TimeDateStamp
= H_GET_32(abfd
, ext
->TimeDateStamp
);
1130 in
->MajorVersion
= H_GET_16(abfd
, ext
->MajorVersion
);
1131 in
->MinorVersion
= H_GET_16(abfd
, ext
->MinorVersion
);
1132 in
->Type
= H_GET_32(abfd
, ext
->Type
);
1133 in
->SizeOfData
= H_GET_32(abfd
, ext
->SizeOfData
);
1134 in
->AddressOfRawData
= H_GET_32(abfd
, ext
->AddressOfRawData
);
1135 in
->PointerToRawData
= H_GET_32(abfd
, ext
->PointerToRawData
);
1139 _bfd_XXi_swap_debugdir_out (bfd
* abfd
, void * inp
, void * extp
)
1141 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) extp
;
1142 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) inp
;
1144 H_PUT_32(abfd
, in
->Characteristics
, ext
->Characteristics
);
1145 H_PUT_32(abfd
, in
->TimeDateStamp
, ext
->TimeDateStamp
);
1146 H_PUT_16(abfd
, in
->MajorVersion
, ext
->MajorVersion
);
1147 H_PUT_16(abfd
, in
->MinorVersion
, ext
->MinorVersion
);
1148 H_PUT_32(abfd
, in
->Type
, ext
->Type
);
1149 H_PUT_32(abfd
, in
->SizeOfData
, ext
->SizeOfData
);
1150 H_PUT_32(abfd
, in
->AddressOfRawData
, ext
->AddressOfRawData
);
1151 H_PUT_32(abfd
, in
->PointerToRawData
, ext
->PointerToRawData
);
1153 return sizeof (struct external_IMAGE_DEBUG_DIRECTORY
);
1157 _bfd_XXi_slurp_codeview_record (bfd
* abfd
, file_ptr where
, unsigned long length
, CODEVIEW_INFO
*cvinfo
)
1161 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1164 if (bfd_bread (buffer
, 256, abfd
) < 4)
1167 /* Ensure null termination of filename. */
1170 cvinfo
->CVSignature
= H_GET_32 (abfd
, buffer
);
1173 if ((cvinfo
->CVSignature
== CVINFO_PDB70_CVSIGNATURE
)
1174 && (length
> sizeof (CV_INFO_PDB70
)))
1176 CV_INFO_PDB70
*cvinfo70
= (CV_INFO_PDB70
*)(buffer
);
1178 cvinfo
->Age
= H_GET_32(abfd
, cvinfo70
->Age
);
1180 /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1181 by 8 single bytes. Byte swap them so we can conveniently treat the GUID
1182 as 16 bytes in big-endian order. */
1183 bfd_putb32 (bfd_getl32 (cvinfo70
->Signature
), cvinfo
->Signature
);
1184 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[4])), &(cvinfo
->Signature
[4]));
1185 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[6])), &(cvinfo
->Signature
[6]));
1186 memcpy (&(cvinfo
->Signature
[8]), &(cvinfo70
->Signature
[8]), 8);
1188 cvinfo
->SignatureLength
= CV_INFO_SIGNATURE_LENGTH
;
1189 // cvinfo->PdbFileName = cvinfo70->PdbFileName;
1193 else if ((cvinfo
->CVSignature
== CVINFO_PDB20_CVSIGNATURE
)
1194 && (length
> sizeof (CV_INFO_PDB20
)))
1196 CV_INFO_PDB20
*cvinfo20
= (CV_INFO_PDB20
*)(buffer
);
1197 cvinfo
->Age
= H_GET_32(abfd
, cvinfo20
->Age
);
1198 memcpy (cvinfo
->Signature
, cvinfo20
->Signature
, 4);
1199 cvinfo
->SignatureLength
= 4;
1200 // cvinfo->PdbFileName = cvinfo20->PdbFileName;
1209 _bfd_XXi_write_codeview_record (bfd
* abfd
, file_ptr where
, CODEVIEW_INFO
*cvinfo
)
1211 const bfd_size_type size
= sizeof (CV_INFO_PDB70
) + 1;
1212 bfd_size_type written
;
1213 CV_INFO_PDB70
*cvinfo70
;
1216 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1219 buffer
= bfd_malloc (size
);
1223 cvinfo70
= (CV_INFO_PDB70
*) buffer
;
1224 H_PUT_32 (abfd
, CVINFO_PDB70_CVSIGNATURE
, cvinfo70
->CvSignature
);
1226 /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1227 in little-endian order, followed by 8 single bytes. */
1228 bfd_putl32 (bfd_getb32 (cvinfo
->Signature
), cvinfo70
->Signature
);
1229 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[4])), &(cvinfo70
->Signature
[4]));
1230 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[6])), &(cvinfo70
->Signature
[6]));
1231 memcpy (&(cvinfo70
->Signature
[8]), &(cvinfo
->Signature
[8]), 8);
1233 H_PUT_32 (abfd
, cvinfo
->Age
, cvinfo70
->Age
);
1234 cvinfo70
->PdbFileName
[0] = '\0';
1236 written
= bfd_bwrite (buffer
, size
, abfd
);
1240 return written
== size
? size
: 0;
1243 static char * dir_names
[IMAGE_NUMBEROF_DIRECTORY_ENTRIES
] =
1245 N_("Export Directory [.edata (or where ever we found it)]"),
1246 N_("Import Directory [parts of .idata]"),
1247 N_("Resource Directory [.rsrc]"),
1248 N_("Exception Directory [.pdata]"),
1249 N_("Security Directory"),
1250 N_("Base Relocation Directory [.reloc]"),
1251 N_("Debug Directory"),
1252 N_("Description Directory"),
1253 N_("Special Directory"),
1254 N_("Thread Storage Directory [.tls]"),
1255 N_("Load Configuration Directory"),
1256 N_("Bound Import Directory"),
1257 N_("Import Address Table Directory"),
1258 N_("Delay Import Directory"),
1259 N_("CLR Runtime Header"),
1263 #ifdef POWERPC_LE_PE
1264 /* The code for the PPC really falls in the "architecture dependent"
1265 category. However, it's not clear that anyone will ever care, so
1266 we're ignoring the issue for now; if/when PPC matters, some of this
1267 may need to go into peicode.h, or arguments passed to enable the
1268 PPC- specific code. */
1272 pe_print_idata (bfd
* abfd
, void * vfile
)
1274 FILE *file
= (FILE *) vfile
;
1279 #ifdef POWERPC_LE_PE
1280 asection
*rel_section
= bfd_get_section_by_name (abfd
, ".reldata");
1283 bfd_size_type datasize
= 0;
1284 bfd_size_type dataoff
;
1288 pe_data_type
*pe
= pe_data (abfd
);
1289 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1293 addr
= extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
;
1295 if (addr
== 0 && extra
->DataDirectory
[PE_IMPORT_TABLE
].Size
== 0)
1297 /* Maybe the extra header isn't there. Look for the section. */
1298 section
= bfd_get_section_by_name (abfd
, ".idata");
1299 if (section
== NULL
)
1302 addr
= section
->vma
;
1303 datasize
= section
->size
;
1309 addr
+= extra
->ImageBase
;
1310 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1312 datasize
= section
->size
;
1313 if (addr
>= section
->vma
&& addr
< section
->vma
+ datasize
)
1317 if (section
== NULL
)
1320 _("\nThere is an import table, but the section containing it could not be found\n"));
1323 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1326 _("\nThere is an import table in %s, but that section has no contents\n"),
1332 /* xgettext:c-format */
1333 fprintf (file
, _("\nThere is an import table in %s at 0x%lx\n"),
1334 section
->name
, (unsigned long) addr
);
1336 dataoff
= addr
- section
->vma
;
1338 #ifdef POWERPC_LE_PE
1339 if (rel_section
!= 0 && rel_section
->size
!= 0)
1341 /* The toc address can be found by taking the starting address,
1342 which on the PPC locates a function descriptor. The
1343 descriptor consists of the function code starting address
1344 followed by the address of the toc. The starting address we
1345 get from the bfd, and the descriptor is supposed to be in the
1346 .reldata section. */
1348 bfd_vma loadable_toc_address
;
1349 bfd_vma toc_address
;
1350 bfd_vma start_address
;
1354 if (!bfd_malloc_and_get_section (abfd
, rel_section
, &data
))
1361 offset
= abfd
->start_address
- rel_section
->vma
;
1363 if (offset
>= rel_section
->size
|| offset
+ 8 > rel_section
->size
)
1370 start_address
= bfd_get_32 (abfd
, data
+ offset
);
1371 loadable_toc_address
= bfd_get_32 (abfd
, data
+ offset
+ 4);
1372 toc_address
= loadable_toc_address
- 32768;
1375 _("\nFunction descriptor located at the start address: %04lx\n"),
1376 (unsigned long int) (abfd
->start_address
));
1378 /* xgettext:c-format */
1379 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1380 start_address
, loadable_toc_address
, toc_address
);
1387 _("\nNo reldata section! Function descriptor not decoded.\n"));
1392 _("\nThe Import Tables (interpreted %s section contents)\n"),
1396 vma: Hint Time Forward DLL First\n\
1397 Table Stamp Chain Name Thunk\n"));
1399 /* Read the whole section. Some of the fields might be before dataoff. */
1400 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
1407 adj
= section
->vma
- extra
->ImageBase
;
1409 /* Print all image import descriptors. */
1410 for (i
= dataoff
; i
+ onaline
<= datasize
; i
+= onaline
)
1414 bfd_vma forward_chain
;
1416 bfd_vma first_thunk
;
1421 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1422 fprintf (file
, " %08lx\t", (unsigned long) (i
+ adj
));
1423 hint_addr
= bfd_get_32 (abfd
, data
+ i
);
1424 time_stamp
= bfd_get_32 (abfd
, data
+ i
+ 4);
1425 forward_chain
= bfd_get_32 (abfd
, data
+ i
+ 8);
1426 dll_name
= bfd_get_32 (abfd
, data
+ i
+ 12);
1427 first_thunk
= bfd_get_32 (abfd
, data
+ i
+ 16);
1429 fprintf (file
, "%08lx %08lx %08lx %08lx %08lx\n",
1430 (unsigned long) hint_addr
,
1431 (unsigned long) time_stamp
,
1432 (unsigned long) forward_chain
,
1433 (unsigned long) dll_name
,
1434 (unsigned long) first_thunk
);
1436 if (hint_addr
== 0 && first_thunk
== 0)
1439 if (dll_name
- adj
>= section
->size
)
1442 dll
= (char *) data
+ dll_name
- adj
;
1443 /* PR 17512 file: 078-12277-0.004. */
1444 bfd_size_type maxlen
= (char *)(data
+ datasize
) - dll
- 1;
1445 fprintf (file
, _("\n\tDLL Name: %.*s\n"), (int) maxlen
, dll
);
1447 /* PR 21546: When the Hint Address is zero,
1448 we try the First Thunk instead. */
1450 hint_addr
= first_thunk
;
1452 if (hint_addr
!= 0 && hint_addr
- adj
< datasize
)
1455 asection
*ft_section
;
1457 bfd_size_type ft_datasize
;
1461 fprintf (file
, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1463 idx
= hint_addr
- adj
;
1465 ft_addr
= first_thunk
+ extra
->ImageBase
;
1466 ft_idx
= first_thunk
- adj
;
1467 ft_data
= data
+ ft_idx
;
1468 ft_datasize
= datasize
- ft_idx
;
1471 if (first_thunk
!= hint_addr
)
1473 /* Find the section which contains the first thunk. */
1474 for (ft_section
= abfd
->sections
;
1476 ft_section
= ft_section
->next
)
1478 if (ft_addr
>= ft_section
->vma
1479 && ft_addr
< ft_section
->vma
+ ft_section
->size
)
1483 if (ft_section
== NULL
)
1486 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1490 /* Now check to see if this section is the same as our current
1491 section. If it is not then we will have to load its data in. */
1492 if (ft_section
!= section
)
1494 ft_idx
= first_thunk
- (ft_section
->vma
- extra
->ImageBase
);
1495 ft_datasize
= ft_section
->size
- ft_idx
;
1496 ft_data
= (bfd_byte
*) bfd_malloc (ft_datasize
);
1497 if (ft_data
== NULL
)
1500 /* Read ft_datasize bytes starting at offset ft_idx. */
1501 if (!bfd_get_section_contents (abfd
, ft_section
, ft_data
,
1502 (bfd_vma
) ft_idx
, ft_datasize
))
1511 /* Print HintName vector entries. */
1512 #ifdef COFF_WITH_pex64
1513 for (j
= 0; idx
+ j
+ 8 <= datasize
; j
+= 8)
1516 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1517 unsigned long member_high
= bfd_get_32 (abfd
, data
+ idx
+ j
+ 4);
1519 if (!member
&& !member_high
)
1524 if (HighBitSet (member_high
))
1525 fprintf (file
, "\t%lx%08lx\t %4lx%08lx <none>",
1526 member_high
, member
,
1527 WithoutHighBit (member_high
), member
);
1528 /* PR binutils/17512: Handle corrupt PE data. */
1529 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1530 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1536 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1537 member_name
= (char *) data
+ amt
+ 2;
1538 fprintf (file
, "\t%04lx\t %4d %.*s",member
, ordinal
,
1539 (int) (datasize
- (amt
+ 2)), member_name
);
1542 /* If the time stamp is not zero, the import address
1543 table holds actual addresses. */
1546 && first_thunk
!= hint_addr
1547 && j
+ 4 <= ft_datasize
)
1548 fprintf (file
, "\t%04lx",
1549 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1550 fprintf (file
, "\n");
1553 for (j
= 0; idx
+ j
+ 4 <= datasize
; j
+= 4)
1556 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1558 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1564 if (HighBitSet (member
))
1565 fprintf (file
, "\t%04lx\t %4lu <none>",
1566 member
, WithoutHighBit (member
));
1567 /* PR binutils/17512: Handle corrupt PE data. */
1568 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1569 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1575 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1576 member_name
= (char *) data
+ amt
+ 2;
1577 fprintf (file
, "\t%04lx\t %4d %.*s",
1579 (int) (datasize
- (amt
+ 2)), member_name
);
1582 /* If the time stamp is not zero, the import address
1583 table holds actual addresses. */
1586 && first_thunk
!= hint_addr
1587 && j
+ 4 <= ft_datasize
)
1588 fprintf (file
, "\t%04lx",
1589 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1591 fprintf (file
, "\n");
1598 fprintf (file
, "\n");
1607 pe_print_edata (bfd
* abfd
, void * vfile
)
1609 FILE *file
= (FILE *) vfile
;
1612 bfd_size_type datasize
= 0;
1613 bfd_size_type dataoff
;
1618 long export_flags
; /* Reserved - should be zero. */
1622 bfd_vma name
; /* RVA - relative to image base. */
1623 long base
; /* Ordinal base. */
1624 unsigned long num_functions
;/* Number in the export address table. */
1625 unsigned long num_names
; /* Number in the name pointer table. */
1626 bfd_vma eat_addr
; /* RVA to the export address table. */
1627 bfd_vma npt_addr
; /* RVA to the Export Name Pointer Table. */
1628 bfd_vma ot_addr
; /* RVA to the Ordinal Table. */
1631 pe_data_type
*pe
= pe_data (abfd
);
1632 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1636 addr
= extra
->DataDirectory
[PE_EXPORT_TABLE
].VirtualAddress
;
1638 if (addr
== 0 && extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
== 0)
1640 /* Maybe the extra header isn't there. Look for the section. */
1641 section
= bfd_get_section_by_name (abfd
, ".edata");
1642 if (section
== NULL
)
1645 addr
= section
->vma
;
1647 datasize
= section
->size
;
1653 addr
+= extra
->ImageBase
;
1655 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1656 if (addr
>= section
->vma
&& addr
< section
->vma
+ section
->size
)
1659 if (section
== NULL
)
1662 _("\nThere is an export table, but the section containing it could not be found\n"));
1665 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1668 _("\nThere is an export table in %s, but that section has no contents\n"),
1673 dataoff
= addr
- section
->vma
;
1674 datasize
= extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
;
1675 if (dataoff
> section
->size
1676 || datasize
> section
->size
- dataoff
)
1679 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1685 /* PR 17512: Handle corrupt PE binaries. */
1689 /* xgettext:c-format */
1690 _("\nThere is an export table in %s, but it is too small (%d)\n"),
1691 section
->name
, (int) datasize
);
1695 /* xgettext:c-format */
1696 fprintf (file
, _("\nThere is an export table in %s at 0x%lx\n"),
1697 section
->name
, (unsigned long) addr
);
1699 data
= (bfd_byte
*) bfd_malloc (datasize
);
1703 if (! bfd_get_section_contents (abfd
, section
, data
,
1704 (file_ptr
) dataoff
, datasize
))
1707 /* Go get Export Directory Table. */
1708 edt
.export_flags
= bfd_get_32 (abfd
, data
+ 0);
1709 edt
.time_stamp
= bfd_get_32 (abfd
, data
+ 4);
1710 edt
.major_ver
= bfd_get_16 (abfd
, data
+ 8);
1711 edt
.minor_ver
= bfd_get_16 (abfd
, data
+ 10);
1712 edt
.name
= bfd_get_32 (abfd
, data
+ 12);
1713 edt
.base
= bfd_get_32 (abfd
, data
+ 16);
1714 edt
.num_functions
= bfd_get_32 (abfd
, data
+ 20);
1715 edt
.num_names
= bfd_get_32 (abfd
, data
+ 24);
1716 edt
.eat_addr
= bfd_get_32 (abfd
, data
+ 28);
1717 edt
.npt_addr
= bfd_get_32 (abfd
, data
+ 32);
1718 edt
.ot_addr
= bfd_get_32 (abfd
, data
+ 36);
1720 adj
= section
->vma
- extra
->ImageBase
+ dataoff
;
1722 /* Dump the EDT first. */
1724 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1728 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt
.export_flags
);
1731 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt
.time_stamp
);
1734 /* xgettext:c-format */
1735 _("Major/Minor \t\t\t%d/%d\n"), edt
.major_ver
, edt
.minor_ver
);
1738 _("Name \t\t\t\t"));
1739 bfd_fprintf_vma (abfd
, file
, edt
.name
);
1741 if ((edt
.name
>= adj
) && (edt
.name
< adj
+ datasize
))
1742 fprintf (file
, " %.*s\n",
1743 (int) (datasize
- (edt
.name
- adj
)),
1744 data
+ edt
.name
- adj
);
1746 fprintf (file
, "(outside .edata section)\n");
1749 _("Ordinal Base \t\t\t%ld\n"), edt
.base
);
1755 _("\tExport Address Table \t\t%08lx\n"),
1759 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt
.num_names
);
1762 _("Table Addresses\n"));
1765 _("\tExport Address Table \t\t"));
1766 bfd_fprintf_vma (abfd
, file
, edt
.eat_addr
);
1767 fprintf (file
, "\n");
1770 _("\tName Pointer Table \t\t"));
1771 bfd_fprintf_vma (abfd
, file
, edt
.npt_addr
);
1772 fprintf (file
, "\n");
1775 _("\tOrdinal Table \t\t\t"));
1776 bfd_fprintf_vma (abfd
, file
, edt
.ot_addr
);
1777 fprintf (file
, "\n");
1779 /* The next table to find is the Export Address Table. It's basically
1780 a list of pointers that either locate a function in this dll, or
1781 forward the call to another dll. Something like:
1786 } export_address_table_entry; */
1789 _("\nExport Address Table -- Ordinal Base %ld\n"),
1792 /* PR 17512: Handle corrupt PE binaries. */
1793 /* PR 17512 file: 140-165018-0.004. */
1794 if (edt
.eat_addr
- adj
>= datasize
1795 /* PR 17512: file: 092b1829 */
1796 || (edt
.num_functions
+ 1) * 4 < edt
.num_functions
1797 || edt
.eat_addr
- adj
+ (edt
.num_functions
+ 1) * 4 > datasize
)
1798 fprintf (file
, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1799 (long) edt
.eat_addr
,
1800 (long) edt
.num_functions
);
1801 else for (i
= 0; i
< edt
.num_functions
; ++i
)
1803 bfd_vma eat_member
= bfd_get_32 (abfd
,
1804 data
+ edt
.eat_addr
+ (i
* 4) - adj
);
1805 if (eat_member
== 0)
1808 if (eat_member
- adj
<= datasize
)
1810 /* This rva is to a name (forwarding function) in our section. */
1811 /* Should locate a function descriptor. */
1813 "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1815 (long) (i
+ edt
.base
),
1816 (unsigned long) eat_member
,
1818 (int)(datasize
- (eat_member
- adj
)),
1819 data
+ eat_member
- adj
);
1823 /* Should locate a function descriptor in the reldata section. */
1825 "\t[%4ld] +base[%4ld] %04lx %s\n",
1827 (long) (i
+ edt
.base
),
1828 (unsigned long) eat_member
,
1833 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1834 /* Dump them in parallel for clarity. */
1836 _("\n[Ordinal/Name Pointer] Table\n"));
1838 /* PR 17512: Handle corrupt PE binaries. */
1839 if (edt
.npt_addr
+ (edt
.num_names
* 4) - adj
>= datasize
1840 /* PR 17512: file: bb68816e. */
1841 || edt
.num_names
* 4 < edt
.num_names
1842 || (data
+ edt
.npt_addr
- adj
) < data
)
1843 /* xgettext:c-format */
1844 fprintf (file
, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1845 (long) edt
.npt_addr
,
1846 (long) edt
.num_names
);
1847 /* PR 17512: file: 140-147171-0.004. */
1848 else if (edt
.ot_addr
+ (edt
.num_names
* 2) - adj
>= datasize
1849 || data
+ edt
.ot_addr
- adj
< data
)
1850 /* xgettext:c-format */
1851 fprintf (file
, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1853 (long) edt
.num_names
);
1854 else for (i
= 0; i
< edt
.num_names
; ++i
)
1859 ord
= bfd_get_16 (abfd
, data
+ edt
.ot_addr
+ (i
* 2) - adj
);
1860 name_ptr
= bfd_get_32 (abfd
, data
+ edt
.npt_addr
+ (i
* 4) - adj
);
1862 if ((name_ptr
- adj
) >= datasize
)
1864 /* xgettext:c-format */
1865 fprintf (file
, _("\t[%4ld] <corrupt offset: %lx>\n"),
1866 (long) ord
, (long) name_ptr
);
1870 char * name
= (char *) data
+ name_ptr
- adj
;
1872 fprintf (file
, "\t[%4ld] %.*s\n", (long) ord
,
1873 (int)((char *)(data
+ datasize
) - name
), name
);
1882 /* This really is architecture dependent. On IA-64, a .pdata entry
1883 consists of three dwords containing relative virtual addresses that
1884 specify the start and end address of the code range the entry
1885 covers and the address of the corresponding unwind info data.
1887 On ARM and SH-4, a compressed PDATA structure is used :
1888 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1889 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1890 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1892 This is the version for uncompressed data. */
1895 pe_print_pdata (bfd
* abfd
, void * vfile
)
1897 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1898 # define PDATA_ROW_SIZE (3 * 8)
1900 # define PDATA_ROW_SIZE (5 * 4)
1902 FILE *file
= (FILE *) vfile
;
1904 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1905 bfd_size_type datasize
= 0;
1907 bfd_size_type start
, stop
;
1908 int onaline
= PDATA_ROW_SIZE
;
1911 || coff_section_data (abfd
, section
) == NULL
1912 || pei_section_data (abfd
, section
) == NULL
)
1915 stop
= pei_section_data (abfd
, section
)->virt_size
;
1916 if ((stop
% onaline
) != 0)
1918 /* xgettext:c-format */
1919 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
1920 (long) stop
, onaline
);
1923 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1924 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1926 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1929 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1930 \t\tAddress Address Handler Data Address Mask\n"));
1933 datasize
= section
->size
;
1937 /* PR 17512: file: 002-193900-0.004. */
1938 if (datasize
< stop
)
1940 /* xgettext:c-format */
1941 fprintf (file
, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"),
1942 (long) stop
, (long) datasize
);
1946 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
1955 for (i
= start
; i
< stop
; i
+= onaline
)
1961 bfd_vma prolog_end_addr
;
1962 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1966 if (i
+ PDATA_ROW_SIZE
> stop
)
1969 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
1970 end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
1971 eh_handler
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 8);
1972 eh_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 12);
1973 prolog_end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 16);
1975 if (begin_addr
== 0 && end_addr
== 0 && eh_handler
== 0
1976 && eh_data
== 0 && prolog_end_addr
== 0)
1977 /* We are probably into the padding of the section now. */
1980 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1981 em_data
= ((eh_handler
& 0x1) << 2) | (prolog_end_addr
& 0x3);
1983 eh_handler
&= ~(bfd_vma
) 0x3;
1984 prolog_end_addr
&= ~(bfd_vma
) 0x3;
1987 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
1988 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
1989 bfd_fprintf_vma (abfd
, file
, end_addr
); fputc (' ', file
);
1990 bfd_fprintf_vma (abfd
, file
, eh_handler
);
1991 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1993 bfd_fprintf_vma (abfd
, file
, eh_data
); fputc (' ', file
);
1994 bfd_fprintf_vma (abfd
, file
, prolog_end_addr
);
1995 fprintf (file
, " %x", em_data
);
1998 #ifdef POWERPC_LE_PE
1999 if (eh_handler
== 0 && eh_data
!= 0)
2001 /* Special bits here, although the meaning may be a little
2002 mysterious. The only one I know for sure is 0x03
2005 0x01 Register Save Millicode
2006 0x02 Register Restore Millicode
2007 0x03 Glue Code Sequence. */
2011 fprintf (file
, _(" Register save millicode"));
2014 fprintf (file
, _(" Register restore millicode"));
2017 fprintf (file
, _(" Glue code sequence"));
2024 fprintf (file
, "\n");
2030 #undef PDATA_ROW_SIZE
2033 typedef struct sym_cache
2040 slurp_symtab (bfd
*abfd
, sym_cache
*psc
)
2042 asymbol
** sy
= NULL
;
2045 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
2051 storage
= bfd_get_symtab_upper_bound (abfd
);
2056 sy
= (asymbol
**) bfd_malloc (storage
);
2061 psc
->symcount
= bfd_canonicalize_symtab (abfd
, sy
);
2062 if (psc
->symcount
< 0)
2068 my_symbol_for_address (bfd
*abfd
, bfd_vma func
, sym_cache
*psc
)
2073 psc
->syms
= slurp_symtab (abfd
, psc
);
2075 for (i
= 0; i
< psc
->symcount
; i
++)
2077 if (psc
->syms
[i
]->section
->vma
+ psc
->syms
[i
]->value
== func
)
2078 return psc
->syms
[i
]->name
;
2085 cleanup_syms (sym_cache
*psc
)
2092 /* This is the version for "compressed" pdata. */
2095 _bfd_XX_print_ce_compressed_pdata (bfd
* abfd
, void * vfile
)
2097 # define PDATA_ROW_SIZE (2 * 4)
2098 FILE *file
= (FILE *) vfile
;
2099 bfd_byte
*data
= NULL
;
2100 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
2101 bfd_size_type datasize
= 0;
2103 bfd_size_type start
, stop
;
2104 int onaline
= PDATA_ROW_SIZE
;
2105 struct sym_cache cache
= {0, 0} ;
2108 || coff_section_data (abfd
, section
) == NULL
2109 || pei_section_data (abfd
, section
) == NULL
)
2112 stop
= pei_section_data (abfd
, section
)->virt_size
;
2113 if ((stop
% onaline
) != 0)
2115 /* xgettext:c-format */
2116 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
2117 (long) stop
, onaline
);
2120 _("\nThe Function Table (interpreted .pdata section contents)\n"));
2123 vma:\t\tBegin Prolog Function Flags Exception EH\n\
2124 \t\tAddress Length Length 32b exc Handler Data\n"));
2126 datasize
= section
->size
;
2130 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2139 for (i
= start
; i
< stop
; i
+= onaline
)
2143 bfd_vma prolog_length
, function_length
;
2144 int flag32bit
, exception_flag
;
2147 if (i
+ PDATA_ROW_SIZE
> stop
)
2150 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
2151 other_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
2153 if (begin_addr
== 0 && other_data
== 0)
2154 /* We are probably into the padding of the section now. */
2157 prolog_length
= (other_data
& 0x000000FF);
2158 function_length
= (other_data
& 0x3FFFFF00) >> 8;
2159 flag32bit
= (int)((other_data
& 0x40000000) >> 30);
2160 exception_flag
= (int)((other_data
& 0x80000000) >> 31);
2163 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
2164 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
2165 bfd_fprintf_vma (abfd
, file
, prolog_length
); fputc (' ', file
);
2166 bfd_fprintf_vma (abfd
, file
, function_length
); fputc (' ', file
);
2167 fprintf (file
, "%2d %2d ", flag32bit
, exception_flag
);
2169 /* Get the exception handler's address and the data passed from the
2170 .text section. This is really the data that belongs with the .pdata
2171 but got "compressed" out for the ARM and SH4 architectures. */
2172 tsection
= bfd_get_section_by_name (abfd
, ".text");
2173 if (tsection
&& coff_section_data (abfd
, tsection
)
2174 && pei_section_data (abfd
, tsection
))
2176 bfd_vma eh_off
= (begin_addr
- 8) - tsection
->vma
;
2179 tdata
= (bfd_byte
*) bfd_malloc (8);
2182 if (bfd_get_section_contents (abfd
, tsection
, tdata
, eh_off
, 8))
2184 bfd_vma eh
, eh_data
;
2186 eh
= bfd_get_32 (abfd
, tdata
);
2187 eh_data
= bfd_get_32 (abfd
, tdata
+ 4);
2188 fprintf (file
, "%08x ", (unsigned int) eh
);
2189 fprintf (file
, "%08x", (unsigned int) eh_data
);
2192 const char *s
= my_symbol_for_address (abfd
, eh
, &cache
);
2195 fprintf (file
, " (%s) ", s
);
2202 fprintf (file
, "\n");
2207 cleanup_syms (& cache
);
2210 #undef PDATA_ROW_SIZE
2214 #define IMAGE_REL_BASED_HIGHADJ 4
2215 static const char * const tbl
[] =
2229 "UNKNOWN", /* MUST be last. */
2233 pe_print_reloc (bfd
* abfd
, void * vfile
)
2235 FILE *file
= (FILE *) vfile
;
2237 asection
*section
= bfd_get_section_by_name (abfd
, ".reloc");
2240 if (section
== NULL
|| section
->size
== 0 || !(section
->flags
& SEC_HAS_CONTENTS
))
2244 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2246 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2254 end
= data
+ section
->size
;
2255 while (p
+ 8 <= end
)
2258 bfd_vma virtual_address
;
2259 unsigned long number
, size
;
2260 bfd_byte
*chunk_end
;
2262 /* The .reloc section is a sequence of blocks, with a header consisting
2263 of two 32 bit quantities, followed by a number of 16 bit entries. */
2264 virtual_address
= bfd_get_32 (abfd
, p
);
2265 size
= bfd_get_32 (abfd
, p
+ 4);
2267 number
= (size
- 8) / 2;
2273 /* xgettext:c-format */
2274 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2275 (unsigned long) virtual_address
, size
, size
, number
);
2277 chunk_end
= p
- 8 + size
;
2278 if (chunk_end
> end
)
2281 while (p
+ 2 <= chunk_end
)
2283 unsigned short e
= bfd_get_16 (abfd
, p
);
2284 unsigned int t
= (e
& 0xF000) >> 12;
2285 int off
= e
& 0x0FFF;
2287 if (t
>= sizeof (tbl
) / sizeof (tbl
[0]))
2288 t
= (sizeof (tbl
) / sizeof (tbl
[0])) - 1;
2291 /* xgettext:c-format */
2292 _("\treloc %4d offset %4x [%4lx] %s"),
2293 j
, off
, (unsigned long) (off
+ virtual_address
), tbl
[t
]);
2298 /* HIGHADJ takes an argument, - the next record *is* the
2299 low 16 bits of addend. */
2300 if (t
== IMAGE_REL_BASED_HIGHADJ
&& p
+ 2 <= chunk_end
)
2302 fprintf (file
, " (%4x)", (unsigned int) bfd_get_16 (abfd
, p
));
2307 fprintf (file
, "\n");
2316 /* A data structure describing the regions of a .rsrc section.
2317 Some fields are filled in as the section is parsed. */
2319 typedef struct rsrc_regions
2321 bfd_byte
* section_start
;
2322 bfd_byte
* section_end
;
2323 bfd_byte
* strings_start
;
2324 bfd_byte
* resource_start
;
2328 rsrc_print_resource_directory (FILE * , bfd
*, unsigned int, bfd_byte
*,
2329 rsrc_regions
*, bfd_vma
);
2331 /* Print the resource entry at DATA, with the text indented by INDENT.
2332 Recusively calls rsrc_print_resource_directory to print the contents
2333 of directory entries.
2334 Returns the address of the end of the data associated with the entry
2335 or section_end + 1 upon failure. */
2338 rsrc_print_resource_entries (FILE * file
,
2340 unsigned int indent
,
2341 bfd_boolean is_name
,
2343 rsrc_regions
* regions
,
2346 unsigned long entry
, addr
, size
;
2349 if (data
+ 8 >= regions
->section_end
)
2350 return regions
->section_end
+ 1;
2352 /* xgettext:c-format */
2353 fprintf (file
, _("%03x %*.s Entry: "), (int)(data
- regions
->section_start
), indent
, " ");
2355 entry
= (unsigned long) bfd_get_32 (abfd
, data
);
2360 /* Note - the documentation says that this field is an RVA value
2361 but windres appears to produce a section relative offset with
2362 the top bit set. Support both styles for now. */
2363 if (HighBitSet (entry
))
2364 name
= regions
->section_start
+ WithoutHighBit (entry
);
2366 name
= regions
->section_start
+ entry
- rva_bias
;
2368 if (name
+ 2 < regions
->section_end
&& name
> regions
->section_start
)
2372 if (regions
->strings_start
== NULL
)
2373 regions
->strings_start
= name
;
2375 len
= bfd_get_16 (abfd
, name
);
2377 fprintf (file
, _("name: [val: %08lx len %d]: "), entry
, len
);
2379 if (name
+ 2 + len
* 2 < regions
->section_end
)
2381 /* This strange loop is to cope with multibyte characters. */
2388 /* Avoid printing control characters. */
2389 if (c
> 0 && c
< 32)
2390 fprintf (file
, "^%c", c
+ 64);
2392 fprintf (file
, "%.1s", name
);
2397 fprintf (file
, _("<corrupt string length: %#x>\n"), len
);
2398 /* PR binutils/17512: Do not try to continue decoding a
2399 corrupted resource section. It is likely to end up with
2400 reams of extraneous output. FIXME: We could probably
2401 continue if we disable the printing of strings... */
2402 return regions
->section_end
+ 1;
2407 fprintf (file
, _("<corrupt string offset: %#lx>\n"), entry
);
2408 return regions
->section_end
+ 1;
2412 fprintf (file
, _("ID: %#08lx"), entry
);
2414 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
2415 fprintf (file
, _(", Value: %#08lx\n"), entry
);
2417 if (HighBitSet (entry
))
2419 data
= regions
->section_start
+ WithoutHighBit (entry
);
2420 if (data
<= regions
->section_start
|| data
> regions
->section_end
)
2421 return regions
->section_end
+ 1;
2423 /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2424 in the resource table. We need some way to detect this. */
2425 return rsrc_print_resource_directory (file
, abfd
, indent
+ 1, data
,
2429 leaf
= regions
->section_start
+ entry
;
2431 if (leaf
+ 16 >= regions
->section_end
2432 /* PR 17512: file: 055dff7e. */
2433 || leaf
< regions
->section_start
)
2434 return regions
->section_end
+ 1;
2436 /* xgettext:c-format */
2437 fprintf (file
, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2438 (int) (entry
), indent
, " ",
2439 addr
= (long) bfd_get_32 (abfd
, leaf
),
2440 size
= (long) bfd_get_32 (abfd
, leaf
+ 4),
2441 (int) bfd_get_32 (abfd
, leaf
+ 8));
2443 /* Check that the reserved entry is 0. */
2444 if (bfd_get_32 (abfd
, leaf
+ 12) != 0
2445 /* And that the data address/size is valid too. */
2446 || (regions
->section_start
+ (addr
- rva_bias
) + size
> regions
->section_end
))
2447 return regions
->section_end
+ 1;
2449 if (regions
->resource_start
== NULL
)
2450 regions
->resource_start
= regions
->section_start
+ (addr
- rva_bias
);
2452 return regions
->section_start
+ (addr
- rva_bias
) + size
;
2455 #define max(a,b) ((a) > (b) ? (a) : (b))
2456 #define min(a,b) ((a) < (b) ? (a) : (b))
2459 rsrc_print_resource_directory (FILE * file
,
2461 unsigned int indent
,
2463 rsrc_regions
* regions
,
2466 unsigned int num_names
, num_ids
;
2467 bfd_byte
* highest_data
= data
;
2469 if (data
+ 16 >= regions
->section_end
)
2470 return regions
->section_end
+ 1;
2472 fprintf (file
, "%03x %*.s ", (int)(data
- regions
->section_start
), indent
, " ");
2475 case 0: fprintf (file
, "Type"); break;
2476 case 2: fprintf (file
, "Name"); break;
2477 case 4: fprintf (file
, "Language"); break;
2479 fprintf (file
, _("<unknown directory type: %d>\n"), indent
);
2480 /* FIXME: For now we end the printing here. If in the
2481 future more directory types are added to the RSRC spec
2482 then we will need to change this. */
2483 return regions
->section_end
+ 1;
2486 /* xgettext:c-format */
2487 fprintf (file
, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2488 (int) bfd_get_32 (abfd
, data
),
2489 (long) bfd_get_32 (abfd
, data
+ 4),
2490 (int) bfd_get_16 (abfd
, data
+ 8),
2491 (int) bfd_get_16 (abfd
, data
+ 10),
2492 num_names
= (int) bfd_get_16 (abfd
, data
+ 12),
2493 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14));
2496 while (num_names
--)
2498 bfd_byte
* entry_end
;
2500 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, TRUE
,
2501 data
, regions
, rva_bias
);
2503 highest_data
= max (highest_data
, entry_end
);
2504 if (entry_end
>= regions
->section_end
)
2510 bfd_byte
* entry_end
;
2512 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, FALSE
,
2513 data
, regions
, rva_bias
);
2515 highest_data
= max (highest_data
, entry_end
);
2516 if (entry_end
>= regions
->section_end
)
2520 return max (highest_data
, data
);
2523 /* Display the contents of a .rsrc section. We do not try to
2524 reproduce the resources, windres does that. Instead we dump
2525 the tables in a human readable format. */
2528 rsrc_print_section (bfd
* abfd
, void * vfile
)
2532 FILE * file
= (FILE *) vfile
;
2533 bfd_size_type datasize
;
2536 rsrc_regions regions
;
2538 pe
= pe_data (abfd
);
2542 section
= bfd_get_section_by_name (abfd
, ".rsrc");
2543 if (section
== NULL
)
2545 if (!(section
->flags
& SEC_HAS_CONTENTS
))
2548 datasize
= section
->size
;
2552 rva_bias
= section
->vma
- pe
->pe_opthdr
.ImageBase
;
2554 if (! bfd_malloc_and_get_section (abfd
, section
, & data
))
2561 regions
.section_start
= data
;
2562 regions
.section_end
= data
+ datasize
;
2563 regions
.strings_start
= NULL
;
2564 regions
.resource_start
= NULL
;
2567 fprintf (file
, "\nThe .rsrc Resource Directory section:\n");
2569 while (data
< regions
.section_end
)
2571 bfd_byte
* p
= data
;
2573 data
= rsrc_print_resource_directory (file
, abfd
, 0, data
, & regions
, rva_bias
);
2575 if (data
== regions
.section_end
+ 1)
2576 fprintf (file
, _("Corrupt .rsrc section detected!\n"));
2579 /* Align data before continuing. */
2580 int align
= (1 << section
->alignment_power
) - 1;
2582 data
= (bfd_byte
*) (((ptrdiff_t) (data
+ align
)) & ~ align
);
2583 rva_bias
+= data
- p
;
2585 /* For reasons that are unclear .rsrc sections are sometimes created
2586 aligned to a 1^3 boundary even when their alignment is set at
2587 1^2. Catch that case here before we issue a spurious warning
2589 if (data
== (regions
.section_end
- 4))
2590 data
= regions
.section_end
;
2591 else if (data
< regions
.section_end
)
2593 /* If the extra data is all zeros then do not complain.
2594 This is just padding so that the section meets the
2595 page size requirements. */
2596 while (++ data
< regions
.section_end
)
2599 if (data
< regions
.section_end
)
2600 fprintf (file
, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2605 if (regions
.strings_start
!= NULL
)
2606 fprintf (file
, _(" String table starts at offset: %#03x\n"),
2607 (int) (regions
.strings_start
- regions
.section_start
));
2608 if (regions
.resource_start
!= NULL
)
2609 fprintf (file
, _(" Resources start at offset: %#03x\n"),
2610 (int) (regions
.resource_start
- regions
.section_start
));
2612 free (regions
.section_start
);
2616 #define IMAGE_NUMBEROF_DEBUG_TYPES 12
2618 static char * debug_type_names
[IMAGE_NUMBEROF_DEBUG_TYPES
] =
2635 pe_print_debugdata (bfd
* abfd
, void * vfile
)
2637 FILE *file
= (FILE *) vfile
;
2638 pe_data_type
*pe
= pe_data (abfd
);
2639 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2642 bfd_size_type dataoff
;
2645 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2646 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2651 addr
+= extra
->ImageBase
;
2652 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2654 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2658 if (section
== NULL
)
2661 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2664 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
2667 _("\nThere is a debug directory in %s, but that section has no contents\n"),
2671 else if (section
->size
< size
)
2674 _("\nError: section %s contains the debug data starting address but it is too small\n"),
2679 fprintf (file
, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2680 section
->name
, (unsigned long) addr
);
2682 dataoff
= addr
- section
->vma
;
2684 if (size
> (section
->size
- dataoff
))
2686 fprintf (file
, _("The debug data size field in the data directory is too big for the section"));
2691 _("Type Size Rva Offset\n"));
2693 /* Read the whole section. */
2694 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2701 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2703 const char *type_name
;
2704 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2705 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2706 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2708 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2710 if ((idd
.Type
) >= IMAGE_NUMBEROF_DEBUG_TYPES
)
2711 type_name
= debug_type_names
[0];
2713 type_name
= debug_type_names
[idd
.Type
];
2715 fprintf (file
, " %2ld %14s %08lx %08lx %08lx\n",
2716 idd
.Type
, type_name
, idd
.SizeOfData
,
2717 idd
.AddressOfRawData
, idd
.PointerToRawData
);
2719 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_CODEVIEW
)
2721 char signature
[CV_INFO_SIGNATURE_LENGTH
* 2 + 1];
2722 /* PR 17512: file: 065-29434-0.001:0.1
2723 We need to use a 32-bit aligned buffer
2724 to safely read in a codeview record. */
2725 char buffer
[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO
);
2727 CODEVIEW_INFO
*cvinfo
= (CODEVIEW_INFO
*) buffer
;
2729 /* The debug entry doesn't have to have to be in a section,
2730 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2731 if (!_bfd_XXi_slurp_codeview_record (abfd
, (file_ptr
) idd
.PointerToRawData
,
2732 idd
.SizeOfData
, cvinfo
))
2735 for (i
= 0; i
< cvinfo
->SignatureLength
; i
++)
2736 sprintf (&signature
[i
*2], "%02x", cvinfo
->Signature
[i
] & 0xff);
2738 /* xgettext:c-format */
2739 fprintf (file
, _("(format %c%c%c%c signature %s age %ld)\n"),
2740 buffer
[0], buffer
[1], buffer
[2], buffer
[3],
2741 signature
, cvinfo
->Age
);
2745 if (size
% sizeof (struct external_IMAGE_DEBUG_DIRECTORY
) != 0)
2747 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2752 /* Print out the program headers. */
2755 _bfd_XX_print_private_bfd_data_common (bfd
* abfd
, void * vfile
)
2757 FILE *file
= (FILE *) vfile
;
2759 pe_data_type
*pe
= pe_data (abfd
);
2760 struct internal_extra_pe_aouthdr
*i
= &pe
->pe_opthdr
;
2761 const char *subsystem_name
= NULL
;
2764 /* The MS dumpbin program reportedly ands with 0xff0f before
2765 printing the characteristics field. Not sure why. No reason to
2767 fprintf (file
, _("\nCharacteristics 0x%x\n"), pe
->real_flags
);
2769 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2770 PF (IMAGE_FILE_RELOCS_STRIPPED
, "relocations stripped");
2771 PF (IMAGE_FILE_EXECUTABLE_IMAGE
, "executable");
2772 PF (IMAGE_FILE_LINE_NUMS_STRIPPED
, "line numbers stripped");
2773 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED
, "symbols stripped");
2774 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE
, "large address aware");
2775 PF (IMAGE_FILE_BYTES_REVERSED_LO
, "little endian");
2776 PF (IMAGE_FILE_32BIT_MACHINE
, "32 bit words");
2777 PF (IMAGE_FILE_DEBUG_STRIPPED
, "debugging information removed");
2778 PF (IMAGE_FILE_SYSTEM
, "system file");
2779 PF (IMAGE_FILE_DLL
, "DLL");
2780 PF (IMAGE_FILE_BYTES_REVERSED_HI
, "big endian");
2783 /* ctime implies '\n'. */
2785 time_t t
= pe
->coff
.timestamp
;
2786 fprintf (file
, "\nTime/Date\t\t%s", ctime (&t
));
2789 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2790 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2792 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2793 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2795 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2796 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2801 case IMAGE_NT_OPTIONAL_HDR_MAGIC
:
2804 case IMAGE_NT_OPTIONAL_HDR64_MAGIC
:
2807 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC
:
2814 fprintf (file
, "Magic\t\t\t%04x", i
->Magic
);
2816 fprintf (file
, "\t(%s)",name
);
2817 fprintf (file
, "\nMajorLinkerVersion\t%d\n", i
->MajorLinkerVersion
);
2818 fprintf (file
, "MinorLinkerVersion\t%d\n", i
->MinorLinkerVersion
);
2819 fprintf (file
, "SizeOfCode\t\t");
2820 bfd_fprintf_vma (abfd
, file
, i
->SizeOfCode
);
2821 fprintf (file
, "\nSizeOfInitializedData\t");
2822 bfd_fprintf_vma (abfd
, file
, i
->SizeOfInitializedData
);
2823 fprintf (file
, "\nSizeOfUninitializedData\t");
2824 bfd_fprintf_vma (abfd
, file
, i
->SizeOfUninitializedData
);
2825 fprintf (file
, "\nAddressOfEntryPoint\t");
2826 bfd_fprintf_vma (abfd
, file
, i
->AddressOfEntryPoint
);
2827 fprintf (file
, "\nBaseOfCode\t\t");
2828 bfd_fprintf_vma (abfd
, file
, i
->BaseOfCode
);
2829 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2830 /* PE32+ does not have BaseOfData member! */
2831 fprintf (file
, "\nBaseOfData\t\t");
2832 bfd_fprintf_vma (abfd
, file
, i
->BaseOfData
);
2835 fprintf (file
, "\nImageBase\t\t");
2836 bfd_fprintf_vma (abfd
, file
, i
->ImageBase
);
2837 fprintf (file
, "\nSectionAlignment\t%08x\n", i
->SectionAlignment
);
2838 fprintf (file
, "FileAlignment\t\t%08x\n", i
->FileAlignment
);
2839 fprintf (file
, "MajorOSystemVersion\t%d\n", i
->MajorOperatingSystemVersion
);
2840 fprintf (file
, "MinorOSystemVersion\t%d\n", i
->MinorOperatingSystemVersion
);
2841 fprintf (file
, "MajorImageVersion\t%d\n", i
->MajorImageVersion
);
2842 fprintf (file
, "MinorImageVersion\t%d\n", i
->MinorImageVersion
);
2843 fprintf (file
, "MajorSubsystemVersion\t%d\n", i
->MajorSubsystemVersion
);
2844 fprintf (file
, "MinorSubsystemVersion\t%d\n", i
->MinorSubsystemVersion
);
2845 fprintf (file
, "Win32Version\t\t%08x\n", i
->Reserved1
);
2846 fprintf (file
, "SizeOfImage\t\t%08x\n", i
->SizeOfImage
);
2847 fprintf (file
, "SizeOfHeaders\t\t%08x\n", i
->SizeOfHeaders
);
2848 fprintf (file
, "CheckSum\t\t%08x\n", i
->CheckSum
);
2850 switch (i
->Subsystem
)
2852 case IMAGE_SUBSYSTEM_UNKNOWN
:
2853 subsystem_name
= "unspecified";
2855 case IMAGE_SUBSYSTEM_NATIVE
:
2856 subsystem_name
= "NT native";
2858 case IMAGE_SUBSYSTEM_WINDOWS_GUI
:
2859 subsystem_name
= "Windows GUI";
2861 case IMAGE_SUBSYSTEM_WINDOWS_CUI
:
2862 subsystem_name
= "Windows CUI";
2864 case IMAGE_SUBSYSTEM_POSIX_CUI
:
2865 subsystem_name
= "POSIX CUI";
2867 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI
:
2868 subsystem_name
= "Wince CUI";
2870 // These are from UEFI Platform Initialization Specification 1.1.
2871 case IMAGE_SUBSYSTEM_EFI_APPLICATION
:
2872 subsystem_name
= "EFI application";
2874 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
:
2875 subsystem_name
= "EFI boot service driver";
2877 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
:
2878 subsystem_name
= "EFI runtime driver";
2880 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER
:
2881 subsystem_name
= "SAL runtime driver";
2883 // This is from revision 8.0 of the MS PE/COFF spec
2884 case IMAGE_SUBSYSTEM_XBOX
:
2885 subsystem_name
= "XBOX";
2887 // Added default case for clarity - subsystem_name is NULL anyway.
2889 subsystem_name
= NULL
;
2892 fprintf (file
, "Subsystem\t\t%08x", i
->Subsystem
);
2894 fprintf (file
, "\t(%s)", subsystem_name
);
2895 fprintf (file
, "\nDllCharacteristics\t%08x\n", i
->DllCharacteristics
);
2896 fprintf (file
, "SizeOfStackReserve\t");
2897 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackReserve
);
2898 fprintf (file
, "\nSizeOfStackCommit\t");
2899 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackCommit
);
2900 fprintf (file
, "\nSizeOfHeapReserve\t");
2901 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapReserve
);
2902 fprintf (file
, "\nSizeOfHeapCommit\t");
2903 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapCommit
);
2904 fprintf (file
, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i
->LoaderFlags
);
2905 fprintf (file
, "NumberOfRvaAndSizes\t%08lx\n",
2906 (unsigned long) i
->NumberOfRvaAndSizes
);
2908 fprintf (file
, "\nThe Data Directory\n");
2909 for (j
= 0; j
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; j
++)
2911 fprintf (file
, "Entry %1x ", j
);
2912 bfd_fprintf_vma (abfd
, file
, i
->DataDirectory
[j
].VirtualAddress
);
2913 fprintf (file
, " %08lx ", (unsigned long) i
->DataDirectory
[j
].Size
);
2914 fprintf (file
, "%s\n", dir_names
[j
]);
2917 pe_print_idata (abfd
, vfile
);
2918 pe_print_edata (abfd
, vfile
);
2919 if (bfd_coff_have_print_pdata (abfd
))
2920 bfd_coff_print_pdata (abfd
, vfile
);
2922 pe_print_pdata (abfd
, vfile
);
2923 pe_print_reloc (abfd
, vfile
);
2924 pe_print_debugdata (abfd
, file
);
2926 rsrc_print_section (abfd
, vfile
);
2932 is_vma_in_section (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sect
, void *obj
)
2934 bfd_vma addr
= * (bfd_vma
*) obj
;
2935 return (addr
>= sect
->vma
) && (addr
< (sect
->vma
+ sect
->size
));
2939 find_section_by_vma (bfd
*abfd
, bfd_vma addr
)
2941 return bfd_sections_find_if (abfd
, is_vma_in_section
, (void *) & addr
);
2944 /* Copy any private info we understand from the input bfd
2945 to the output bfd. */
2948 _bfd_XX_bfd_copy_private_bfd_data_common (bfd
* ibfd
, bfd
* obfd
)
2950 pe_data_type
*ipe
, *ope
;
2952 /* One day we may try to grok other private data. */
2953 if (ibfd
->xvec
->flavour
!= bfd_target_coff_flavour
2954 || obfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
2957 ipe
= pe_data (ibfd
);
2958 ope
= pe_data (obfd
);
2960 /* pe_opthdr is copied in copy_object. */
2961 ope
->dll
= ipe
->dll
;
2963 /* Don't copy input subsystem if output is different from input. */
2964 if (obfd
->xvec
!= ibfd
->xvec
)
2965 ope
->pe_opthdr
.Subsystem
= IMAGE_SUBSYSTEM_UNKNOWN
;
2967 /* For strip: if we removed .reloc, we'll make a real mess of things
2968 if we don't remove this entry as well. */
2969 if (! pe_data (obfd
)->has_reloc_section
)
2971 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].VirtualAddress
= 0;
2972 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].Size
= 0;
2975 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2976 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2978 if (! pe_data (ibfd
)->has_reloc_section
2979 && ! (pe_data (ibfd
)->real_flags
& IMAGE_FILE_RELOCS_STRIPPED
))
2980 pe_data (obfd
)->dont_strip_reloc
= 1;
2982 /* The file offsets contained in the debug directory need rewriting. */
2983 if (ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
!= 0)
2985 bfd_vma addr
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
2986 + ope
->pe_opthdr
.ImageBase
;
2987 asection
*section
= find_section_by_vma (obfd
, addr
);
2990 if (section
&& bfd_malloc_and_get_section (obfd
, section
, &data
))
2993 struct external_IMAGE_DEBUG_DIRECTORY
*dd
=
2994 (struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ (addr
- section
->vma
));
2996 /* PR 17512: file: 0f15796a. */
2997 if ((unsigned long) ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
2998 > section
->size
- (addr
- section
->vma
))
3000 /* xgettext:c-format */
3002 (_("%pB: Data Directory size (%lx) "
3003 "exceeds space left in section (%" PRIx64
")"),
3004 obfd
, ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
,
3005 (uint64_t) (section
->size
- (addr
- section
->vma
)));
3010 for (i
= 0; i
< ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
3011 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
3013 asection
*ddsection
;
3014 struct external_IMAGE_DEBUG_DIRECTORY
*edd
= &(dd
[i
]);
3015 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
3017 _bfd_XXi_swap_debugdir_in (obfd
, edd
, &idd
);
3019 if (idd
.AddressOfRawData
== 0)
3020 continue; /* RVA 0 means only offset is valid, not handled yet. */
3022 ddsection
= find_section_by_vma (obfd
, idd
.AddressOfRawData
+ ope
->pe_opthdr
.ImageBase
);
3024 continue; /* Not in a section! */
3026 idd
.PointerToRawData
= ddsection
->filepos
+ (idd
.AddressOfRawData
3027 + ope
->pe_opthdr
.ImageBase
) - ddsection
->vma
;
3029 _bfd_XXi_swap_debugdir_out (obfd
, &idd
, edd
);
3032 if (!bfd_set_section_contents (obfd
, section
, data
, 0, section
->size
))
3034 _bfd_error_handler (_("failed to update file offsets in debug directory"));
3042 _bfd_error_handler (_("%pB: failed to read debug data section"), obfd
);
3050 /* Copy private section data. */
3053 _bfd_XX_bfd_copy_private_section_data (bfd
*ibfd
,
3058 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
3059 || bfd_get_flavour (obfd
) != bfd_target_coff_flavour
)
3062 if (coff_section_data (ibfd
, isec
) != NULL
3063 && pei_section_data (ibfd
, isec
) != NULL
)
3065 if (coff_section_data (obfd
, osec
) == NULL
)
3067 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
3068 osec
->used_by_bfd
= bfd_zalloc (obfd
, amt
);
3069 if (osec
->used_by_bfd
== NULL
)
3073 if (pei_section_data (obfd
, osec
) == NULL
)
3075 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
3076 coff_section_data (obfd
, osec
)->tdata
= bfd_zalloc (obfd
, amt
);
3077 if (coff_section_data (obfd
, osec
)->tdata
== NULL
)
3081 pei_section_data (obfd
, osec
)->virt_size
=
3082 pei_section_data (ibfd
, isec
)->virt_size
;
3083 pei_section_data (obfd
, osec
)->pe_flags
=
3084 pei_section_data (ibfd
, isec
)->pe_flags
;
3091 _bfd_XX_get_symbol_info (bfd
* abfd
, asymbol
*symbol
, symbol_info
*ret
)
3093 coff_get_symbol_info (abfd
, symbol
, ret
);
3096 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
3098 sort_x64_pdata (const void *l
, const void *r
)
3100 const char *lp
= (const char *) l
;
3101 const char *rp
= (const char *) r
;
3103 vl
= bfd_getl32 (lp
); vr
= bfd_getl32 (rp
);
3105 return (vl
< vr
? -1 : 1);
3106 /* We compare just begin address. */
3111 /* Functions to process a .rsrc section. */
3113 static unsigned int sizeof_leaves
;
3114 static unsigned int sizeof_strings
;
3115 static unsigned int sizeof_tables_and_entries
;
3118 rsrc_count_directory (bfd
*, bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
3121 rsrc_count_entries (bfd
* abfd
,
3122 bfd_boolean is_name
,
3123 bfd_byte
* datastart
,
3128 unsigned long entry
, addr
, size
;
3130 if (data
+ 8 >= dataend
)
3137 entry
= (long) bfd_get_32 (abfd
, data
);
3139 if (HighBitSet (entry
))
3140 name
= datastart
+ WithoutHighBit (entry
);
3142 name
= datastart
+ entry
- rva_bias
;
3144 if (name
+ 2 >= dataend
|| name
< datastart
)
3147 unsigned int len
= bfd_get_16 (abfd
, name
);
3148 if (len
== 0 || len
> 256)
3152 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
3154 if (HighBitSet (entry
))
3156 data
= datastart
+ WithoutHighBit (entry
);
3158 if (data
<= datastart
|| data
>= dataend
)
3161 return rsrc_count_directory (abfd
, datastart
, data
, dataend
, rva_bias
);
3164 if (datastart
+ entry
+ 16 >= dataend
)
3167 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
);
3168 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4);
3170 return datastart
+ addr
- rva_bias
+ size
;
3174 rsrc_count_directory (bfd
* abfd
,
3175 bfd_byte
* datastart
,
3180 unsigned int num_entries
, num_ids
;
3181 bfd_byte
* highest_data
= data
;
3183 if (data
+ 16 >= dataend
)
3186 num_entries
= (int) bfd_get_16 (abfd
, data
+ 12);
3187 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14);
3189 num_entries
+= num_ids
;
3193 while (num_entries
--)
3195 bfd_byte
* entry_end
;
3197 entry_end
= rsrc_count_entries (abfd
, num_entries
>= num_ids
,
3198 datastart
, data
, dataend
, rva_bias
);
3200 highest_data
= max (highest_data
, entry_end
);
3201 if (entry_end
>= dataend
)
3205 return max (highest_data
, data
);
3208 typedef struct rsrc_dir_chain
3210 unsigned int num_entries
;
3211 struct rsrc_entry
* first_entry
;
3212 struct rsrc_entry
* last_entry
;
3215 typedef struct rsrc_directory
3217 unsigned int characteristics
;
3222 rsrc_dir_chain names
;
3225 struct rsrc_entry
* entry
;
3228 typedef struct rsrc_string
3234 typedef struct rsrc_leaf
3237 unsigned int codepage
;
3241 typedef struct rsrc_entry
3243 bfd_boolean is_name
;
3247 struct rsrc_string name
;
3253 struct rsrc_directory
* directory
;
3254 struct rsrc_leaf
* leaf
;
3257 struct rsrc_entry
* next_entry
;
3258 struct rsrc_directory
* parent
;
3262 rsrc_parse_directory (bfd
*, rsrc_directory
*, bfd_byte
*,
3263 bfd_byte
*, bfd_byte
*, bfd_vma
, rsrc_entry
*);
3266 rsrc_parse_entry (bfd
* abfd
,
3267 bfd_boolean is_name
,
3269 bfd_byte
* datastart
,
3273 rsrc_directory
* parent
)
3275 unsigned long val
, addr
, size
;
3277 val
= bfd_get_32 (abfd
, data
);
3279 entry
->parent
= parent
;
3280 entry
->is_name
= is_name
;
3286 if (HighBitSet (val
))
3288 val
= WithoutHighBit (val
);
3290 address
= datastart
+ val
;
3294 address
= datastart
+ val
- rva_bias
;
3297 if (address
+ 3 > dataend
)
3300 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, address
);
3301 entry
->name_id
.name
.string
= address
+ 2;
3304 entry
->name_id
.id
= val
;
3306 val
= bfd_get_32 (abfd
, data
+ 4);
3308 if (HighBitSet (val
))
3310 entry
->is_dir
= TRUE
;
3311 entry
->value
.directory
= bfd_malloc (sizeof * entry
->value
.directory
);
3312 if (entry
->value
.directory
== NULL
)
3315 return rsrc_parse_directory (abfd
, entry
->value
.directory
,
3317 datastart
+ WithoutHighBit (val
),
3318 dataend
, rva_bias
, entry
);
3321 entry
->is_dir
= FALSE
;
3322 entry
->value
.leaf
= bfd_malloc (sizeof * entry
->value
.leaf
);
3323 if (entry
->value
.leaf
== NULL
)
3326 data
= datastart
+ val
;
3327 if (data
< datastart
|| data
>= dataend
)
3330 addr
= bfd_get_32 (abfd
, data
);
3331 size
= entry
->value
.leaf
->size
= bfd_get_32 (abfd
, data
+ 4);
3332 entry
->value
.leaf
->codepage
= bfd_get_32 (abfd
, data
+ 8);
3333 /* FIXME: We assume that the reserved field (data + 12) is OK. */
3335 entry
->value
.leaf
->data
= bfd_malloc (size
);
3336 if (entry
->value
.leaf
->data
== NULL
)
3339 memcpy (entry
->value
.leaf
->data
, datastart
+ addr
- rva_bias
, size
);
3340 return datastart
+ (addr
- rva_bias
) + size
;
3344 rsrc_parse_entries (bfd
* abfd
,
3345 rsrc_dir_chain
* chain
,
3346 bfd_boolean is_name
,
3347 bfd_byte
* highest_data
,
3348 bfd_byte
* datastart
,
3352 rsrc_directory
* parent
)
3357 if (chain
->num_entries
== 0)
3359 chain
->first_entry
= chain
->last_entry
= NULL
;
3360 return highest_data
;
3363 entry
= bfd_malloc (sizeof * entry
);
3367 chain
->first_entry
= entry
;
3369 for (i
= chain
->num_entries
; i
--;)
3371 bfd_byte
* entry_end
;
3373 entry_end
= rsrc_parse_entry (abfd
, is_name
, entry
, datastart
,
3374 data
, dataend
, rva_bias
, parent
);
3376 highest_data
= max (entry_end
, highest_data
);
3377 if (entry_end
> dataend
)
3382 entry
->next_entry
= bfd_malloc (sizeof * entry
);
3383 entry
= entry
->next_entry
;
3388 entry
->next_entry
= NULL
;
3391 chain
->last_entry
= entry
;
3393 return highest_data
;
3397 rsrc_parse_directory (bfd
* abfd
,
3398 rsrc_directory
* table
,
3399 bfd_byte
* datastart
,
3405 bfd_byte
* highest_data
= data
;
3410 table
->characteristics
= bfd_get_32 (abfd
, data
);
3411 table
->time
= bfd_get_32 (abfd
, data
+ 4);
3412 table
->major
= bfd_get_16 (abfd
, data
+ 8);
3413 table
->minor
= bfd_get_16 (abfd
, data
+ 10);
3414 table
->names
.num_entries
= bfd_get_16 (abfd
, data
+ 12);
3415 table
->ids
.num_entries
= bfd_get_16 (abfd
, data
+ 14);
3416 table
->entry
= entry
;
3420 highest_data
= rsrc_parse_entries (abfd
, & table
->names
, TRUE
, data
,
3421 datastart
, data
, dataend
, rva_bias
, table
);
3422 data
+= table
->names
.num_entries
* 8;
3424 highest_data
= rsrc_parse_entries (abfd
, & table
->ids
, FALSE
, highest_data
,
3425 datastart
, data
, dataend
, rva_bias
, table
);
3426 data
+= table
->ids
.num_entries
* 8;
3428 return max (highest_data
, data
);
3431 typedef struct rsrc_write_data
3434 bfd_byte
* datastart
;
3435 bfd_byte
* next_table
;
3436 bfd_byte
* next_leaf
;
3437 bfd_byte
* next_string
;
3438 bfd_byte
* next_data
;
3443 rsrc_write_string (rsrc_write_data
* data
,
3444 rsrc_string
* string
)
3446 bfd_put_16 (data
->abfd
, string
->len
, data
->next_string
);
3447 memcpy (data
->next_string
+ 2, string
->string
, string
->len
* 2);
3448 data
->next_string
+= (string
->len
+ 1) * 2;
3451 static inline unsigned int
3452 rsrc_compute_rva (rsrc_write_data
* data
,
3455 return (addr
- data
->datastart
) + data
->rva_bias
;
3459 rsrc_write_leaf (rsrc_write_data
* data
,
3462 bfd_put_32 (data
->abfd
, rsrc_compute_rva (data
, data
->next_data
),
3464 bfd_put_32 (data
->abfd
, leaf
->size
, data
->next_leaf
+ 4);
3465 bfd_put_32 (data
->abfd
, leaf
->codepage
, data
->next_leaf
+ 8);
3466 bfd_put_32 (data
->abfd
, 0 /*reserved*/, data
->next_leaf
+ 12);
3467 data
->next_leaf
+= 16;
3469 memcpy (data
->next_data
, leaf
->data
, leaf
->size
);
3470 /* An undocumented feature of Windows resources is that each unit
3471 of raw data is 8-byte aligned... */
3472 data
->next_data
+= ((leaf
->size
+ 7) & ~7);
3475 static void rsrc_write_directory (rsrc_write_data
*, rsrc_directory
*);
3478 rsrc_write_entry (rsrc_write_data
* data
,
3484 bfd_put_32 (data
->abfd
,
3485 SetHighBit (data
->next_string
- data
->datastart
),
3487 rsrc_write_string (data
, & entry
->name_id
.name
);
3490 bfd_put_32 (data
->abfd
, entry
->name_id
.id
, where
);
3494 bfd_put_32 (data
->abfd
,
3495 SetHighBit (data
->next_table
- data
->datastart
),
3497 rsrc_write_directory (data
, entry
->value
.directory
);
3501 bfd_put_32 (data
->abfd
, data
->next_leaf
- data
->datastart
, where
+ 4);
3502 rsrc_write_leaf (data
, entry
->value
.leaf
);
3507 rsrc_compute_region_sizes (rsrc_directory
* dir
)
3509 struct rsrc_entry
* entry
;
3514 sizeof_tables_and_entries
+= 16;
3516 for (entry
= dir
->names
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3518 sizeof_tables_and_entries
+= 8;
3520 sizeof_strings
+= (entry
->name_id
.name
.len
+ 1) * 2;
3523 rsrc_compute_region_sizes (entry
->value
.directory
);
3525 sizeof_leaves
+= 16;
3528 for (entry
= dir
->ids
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3530 sizeof_tables_and_entries
+= 8;
3533 rsrc_compute_region_sizes (entry
->value
.directory
);
3535 sizeof_leaves
+= 16;
3540 rsrc_write_directory (rsrc_write_data
* data
,
3541 rsrc_directory
* dir
)
3545 bfd_byte
* next_entry
;
3548 bfd_put_32 (data
->abfd
, dir
->characteristics
, data
->next_table
);
3549 bfd_put_32 (data
->abfd
, 0 /*dir->time*/, data
->next_table
+ 4);
3550 bfd_put_16 (data
->abfd
, dir
->major
, data
->next_table
+ 8);
3551 bfd_put_16 (data
->abfd
, dir
->minor
, data
->next_table
+ 10);
3552 bfd_put_16 (data
->abfd
, dir
->names
.num_entries
, data
->next_table
+ 12);
3553 bfd_put_16 (data
->abfd
, dir
->ids
.num_entries
, data
->next_table
+ 14);
3555 /* Compute where the entries and the next table will be placed. */
3556 next_entry
= data
->next_table
+ 16;
3557 data
->next_table
= next_entry
+ (dir
->names
.num_entries
* 8)
3558 + (dir
->ids
.num_entries
* 8);
3559 nt
= data
->next_table
;
3561 /* Write the entries. */
3562 for (i
= dir
->names
.num_entries
, entry
= dir
->names
.first_entry
;
3563 i
> 0 && entry
!= NULL
;
3564 i
--, entry
= entry
->next_entry
)
3566 BFD_ASSERT (entry
->is_name
);
3567 rsrc_write_entry (data
, next_entry
, entry
);
3570 BFD_ASSERT (i
== 0);
3571 BFD_ASSERT (entry
== NULL
);
3573 for (i
= dir
->ids
.num_entries
, entry
= dir
->ids
.first_entry
;
3574 i
> 0 && entry
!= NULL
;
3575 i
--, entry
= entry
->next_entry
)
3577 BFD_ASSERT (! entry
->is_name
);
3578 rsrc_write_entry (data
, next_entry
, entry
);
3581 BFD_ASSERT (i
== 0);
3582 BFD_ASSERT (entry
== NULL
);
3583 BFD_ASSERT (nt
== next_entry
);
3586 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3587 /* Return the length (number of units) of the first character in S,
3588 putting its 'ucs4_t' representation in *PUC. */
3591 #if defined HAVE_WCTYPE_H
3592 u16_mbtouc (wint_t * puc
, const unsigned short * s
, unsigned int n
)
3594 u16_mbtouc (wchar_t * puc
, const unsigned short * s
, unsigned int n
)
3597 unsigned short c
= * s
;
3599 if (c
< 0xd800 || c
>= 0xe000)
3609 if (s
[1] >= 0xdc00 && s
[1] < 0xe000)
3611 *puc
= 0x10000 + ((c
- 0xd800) << 10) + (s
[1] - 0xdc00);
3617 /* Incomplete multibyte character. */
3623 /* Invalid multibyte character. */
3627 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3629 /* Perform a comparison of two entries. */
3631 rsrc_cmp (bfd_boolean is_name
, rsrc_entry
* a
, rsrc_entry
* b
)
3640 return a
->name_id
.id
- b
->name_id
.id
;
3642 /* We have to perform a case insenstive, unicode string comparison... */
3643 astring
= a
->name_id
.name
.string
;
3644 alen
= a
->name_id
.name
.len
;
3645 bstring
= b
->name_id
.name
.string
;
3646 blen
= b
->name_id
.name
.len
;
3648 #if defined __CYGWIN__ || defined __MINGW32__
3649 /* Under Windows hosts (both Cygwin and Mingw types),
3650 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3651 function however goes by different names in the two environments... */
3655 #define rscpcmp wcsncasecmp
3658 #define rscpcmp wcsnicmp
3661 res
= rscpcmp ((const wchar_t *) astring
, (const wchar_t *) bstring
,
3664 #elif defined HAVE_WCHAR_H
3669 for (i
= min (alen
, blen
); i
--; astring
+= 2, bstring
+= 2)
3671 #if defined HAVE_WCTYPE_H
3679 /* Convert UTF-16 unicode characters into wchar_t characters
3680 so that we can then perform a case insensitive comparison. */
3681 unsigned int Alen
= u16_mbtouc (& awc
, (const unsigned short *) astring
, 2);
3682 unsigned int Blen
= u16_mbtouc (& bwc
, (const unsigned short *) bstring
, 2);
3687 #ifdef HAVE_WCTYPE_H
3688 awc
= towlower (awc
);
3689 bwc
= towlower (bwc
);
3693 res
= wcsncasecmp (& awc
, & bwc
, 1);
3700 /* Do the best we can - a case sensitive, untranslated comparison. */
3701 res
= memcmp (astring
, bstring
, min (alen
, blen
) * 2);
3711 rsrc_print_name (char * buffer
, rsrc_string string
)
3714 bfd_byte
* name
= string
.string
;
3716 for (i
= string
.len
; i
--; name
+= 2)
3717 sprintf (buffer
+ strlen (buffer
), "%.1s", name
);
3721 rsrc_resource_name (rsrc_entry
* entry
, rsrc_directory
* dir
)
3723 static char buffer
[256];
3724 bfd_boolean is_string
= FALSE
;
3728 if (dir
!= NULL
&& dir
->entry
!= NULL
&& dir
->entry
->parent
!= NULL
3729 && dir
->entry
->parent
->entry
!= NULL
)
3731 strcpy (buffer
, "type: ");
3732 if (dir
->entry
->parent
->entry
->is_name
)
3733 rsrc_print_name (buffer
+ strlen (buffer
),
3734 dir
->entry
->parent
->entry
->name_id
.name
);
3737 unsigned int id
= dir
->entry
->parent
->entry
->name_id
.id
;
3739 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3742 case 1: strcat (buffer
, " (CURSOR)"); break;
3743 case 2: strcat (buffer
, " (BITMAP)"); break;
3744 case 3: strcat (buffer
, " (ICON)"); break;
3745 case 4: strcat (buffer
, " (MENU)"); break;
3746 case 5: strcat (buffer
, " (DIALOG)"); break;
3747 case 6: strcat (buffer
, " (STRING)"); is_string
= TRUE
; break;
3748 case 7: strcat (buffer
, " (FONTDIR)"); break;
3749 case 8: strcat (buffer
, " (FONT)"); break;
3750 case 9: strcat (buffer
, " (ACCELERATOR)"); break;
3751 case 10: strcat (buffer
, " (RCDATA)"); break;
3752 case 11: strcat (buffer
, " (MESSAGETABLE)"); break;
3753 case 12: strcat (buffer
, " (GROUP_CURSOR)"); break;
3754 case 14: strcat (buffer
, " (GROUP_ICON)"); break;
3755 case 16: strcat (buffer
, " (VERSION)"); break;
3756 case 17: strcat (buffer
, " (DLGINCLUDE)"); break;
3757 case 19: strcat (buffer
, " (PLUGPLAY)"); break;
3758 case 20: strcat (buffer
, " (VXD)"); break;
3759 case 21: strcat (buffer
, " (ANICURSOR)"); break;
3760 case 22: strcat (buffer
, " (ANIICON)"); break;
3761 case 23: strcat (buffer
, " (HTML)"); break;
3762 case 24: strcat (buffer
, " (MANIFEST)"); break;
3763 case 240: strcat (buffer
, " (DLGINIT)"); break;
3764 case 241: strcat (buffer
, " (TOOLBAR)"); break;
3769 if (dir
!= NULL
&& dir
->entry
!= NULL
)
3771 strcat (buffer
, " name: ");
3772 if (dir
->entry
->is_name
)
3773 rsrc_print_name (buffer
+ strlen (buffer
), dir
->entry
->name_id
.name
);
3776 unsigned int id
= dir
->entry
->name_id
.id
;
3778 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3781 sprintf (buffer
+ strlen (buffer
), " (resource id range: %d - %d)",
3782 (id
- 1) << 4, (id
<< 4) - 1);
3788 strcat (buffer
, " lang: ");
3791 rsrc_print_name (buffer
+ strlen (buffer
), entry
->name_id
.name
);
3793 sprintf (buffer
+ strlen (buffer
), "%x", entry
->name_id
.id
);
3799 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3800 their ID is stored in the NAME entry. The bottom four bits are used as
3801 an index into unicode string table that makes up the data of the leaf.
3802 So identical type-name-lang string resources may not actually be
3805 This function is called when we have detected two string resources with
3806 match top-28-bit IDs. We have to scan the string tables inside the leaves
3807 and discover if there are any real collisions. If there are then we report
3808 them and return FALSE. Otherwise we copy any strings from B into A and
3809 then return TRUE. */
3812 rsrc_merge_string_entries (rsrc_entry
* a ATTRIBUTE_UNUSED
,
3813 rsrc_entry
* b ATTRIBUTE_UNUSED
)
3815 unsigned int copy_needed
= 0;
3819 bfd_byte
* new_data
;
3822 /* Step one: Find out what we have to do. */
3823 BFD_ASSERT (! a
->is_dir
);
3824 astring
= a
->value
.leaf
->data
;
3826 BFD_ASSERT (! b
->is_dir
);
3827 bstring
= b
->value
.leaf
->data
;
3829 for (i
= 0; i
< 16; i
++)
3831 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3832 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3836 copy_needed
+= blen
* 2;
3840 else if (alen
!= blen
)
3841 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3843 /* alen == blen != 0. We might have two identical strings. If so we
3844 can ignore the second one. There is no need for wchar_t vs UTF-16
3845 theatrics here - we are only interested in (case sensitive) equality. */
3846 else if (memcmp (astring
+ 2, bstring
+ 2, alen
* 2) != 0)
3849 astring
+= (alen
+ 1) * 2;
3850 bstring
+= (blen
+ 1) * 2;
3855 if (a
->parent
!= NULL
3856 && a
->parent
->entry
!= NULL
3857 && !a
->parent
->entry
->is_name
)
3858 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3859 ((a
->parent
->entry
->name_id
.id
- 1) << 4) + i
);
3863 if (copy_needed
== 0)
3866 /* If we reach here then A and B must both have non-colliding strings.
3867 (We never get string resources with fully empty string tables).
3868 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3870 new_data
= bfd_malloc (a
->value
.leaf
->size
+ copy_needed
);
3871 if (new_data
== NULL
)
3875 astring
= a
->value
.leaf
->data
;
3876 bstring
= b
->value
.leaf
->data
;
3878 for (i
= 0; i
< 16; i
++)
3880 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3881 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3885 memcpy (nstring
, astring
, (alen
+ 1) * 2);
3886 nstring
+= (alen
+ 1) * 2;
3890 memcpy (nstring
, bstring
, (blen
+ 1) * 2);
3891 nstring
+= (blen
+ 1) * 2;
3899 astring
+= (alen
+ 1) * 2;
3900 bstring
+= (blen
+ 1) * 2;
3903 BFD_ASSERT (nstring
- new_data
== (signed) (a
->value
.leaf
->size
+ copy_needed
));
3905 free (a
->value
.leaf
->data
);
3906 a
->value
.leaf
->data
= new_data
;
3907 a
->value
.leaf
->size
+= copy_needed
;
3912 static void rsrc_merge (rsrc_entry
*, rsrc_entry
*);
3914 /* Sort the entries in given part of the directory.
3915 We use an old fashioned bubble sort because we are dealing
3916 with lists and we want to handle matches specially. */
3919 rsrc_sort_entries (rsrc_dir_chain
* chain
,
3920 bfd_boolean is_name
,
3921 rsrc_directory
* dir
)
3925 rsrc_entry
** points_to_entry
;
3926 bfd_boolean swapped
;
3928 if (chain
->num_entries
< 2)
3934 points_to_entry
= & chain
->first_entry
;
3935 entry
= * points_to_entry
;
3936 next
= entry
->next_entry
;
3940 signed int cmp
= rsrc_cmp (is_name
, entry
, next
);
3944 entry
->next_entry
= next
->next_entry
;
3945 next
->next_entry
= entry
;
3946 * points_to_entry
= next
;
3947 points_to_entry
= & next
->next_entry
;
3948 next
= entry
->next_entry
;
3953 if (entry
->is_dir
&& next
->is_dir
)
3955 /* When we encounter identical directory entries we have to
3956 merge them together. The exception to this rule is for
3957 resource manifests - there can only be one of these,
3958 even if they differ in language. Zero-language manifests
3959 are assumed to be default manifests (provided by the
3960 Cygwin/MinGW build system) and these can be silently dropped,
3961 unless that would reduce the number of manifests to zero.
3962 There should only ever be one non-zero lang manifest -
3963 if there are more it is an error. A non-zero lang
3964 manifest takes precedence over a default manifest. */
3966 && entry
->name_id
.id
== 1
3968 && dir
->entry
!= NULL
3969 && !dir
->entry
->is_name
3970 && dir
->entry
->name_id
.id
== 0x18)
3972 if (next
->value
.directory
->names
.num_entries
== 0
3973 && next
->value
.directory
->ids
.num_entries
== 1
3974 && !next
->value
.directory
->ids
.first_entry
->is_name
3975 && next
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3976 /* Fall through so that NEXT is dropped. */
3978 else if (entry
->value
.directory
->names
.num_entries
== 0
3979 && entry
->value
.directory
->ids
.num_entries
== 1
3980 && !entry
->value
.directory
->ids
.first_entry
->is_name
3981 && entry
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3983 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
3984 entry
->next_entry
= next
->next_entry
;
3985 next
->next_entry
= entry
;
3986 * points_to_entry
= next
;
3987 points_to_entry
= & next
->next_entry
;
3988 next
= entry
->next_entry
;
3993 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3994 bfd_set_error (bfd_error_file_truncated
);
3998 /* Unhook NEXT from the chain. */
3999 /* FIXME: memory loss here. */
4000 entry
->next_entry
= next
->next_entry
;
4001 chain
->num_entries
--;
4002 if (chain
->num_entries
< 2)
4004 next
= next
->next_entry
;
4007 rsrc_merge (entry
, next
);
4009 else if (entry
->is_dir
!= next
->is_dir
)
4011 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
4012 bfd_set_error (bfd_error_file_truncated
);
4017 /* Otherwise with identical leaves we issue an error
4018 message - because there should never be duplicates.
4019 The exception is Type 18/Name 1/Lang 0 which is the
4020 defaul manifest - this can just be dropped. */
4022 && entry
->name_id
.id
== 0
4024 && dir
->entry
!= NULL
4025 && !dir
->entry
->is_name
4026 && dir
->entry
->name_id
.id
== 1
4027 && dir
->entry
->parent
!= NULL
4028 && dir
->entry
->parent
->entry
!= NULL
4029 && !dir
->entry
->parent
->entry
->is_name
4030 && dir
->entry
->parent
->entry
->name_id
.id
== 0x18 /* RT_MANIFEST */)
4032 else if (dir
!= NULL
4033 && dir
->entry
!= NULL
4034 && dir
->entry
->parent
!= NULL
4035 && dir
->entry
->parent
->entry
!= NULL
4036 && !dir
->entry
->parent
->entry
->is_name
4037 && dir
->entry
->parent
->entry
->name_id
.id
== 0x6 /* RT_STRING */)
4039 /* Strings need special handling. */
4040 if (! rsrc_merge_string_entries (entry
, next
))
4042 /* _bfd_error_handler should have been called inside merge_strings. */
4043 bfd_set_error (bfd_error_file_truncated
);
4050 || dir
->entry
== NULL
4051 || dir
->entry
->parent
== NULL
4052 || dir
->entry
->parent
->entry
== NULL
)
4053 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
4055 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
4056 rsrc_resource_name (entry
, dir
));
4057 bfd_set_error (bfd_error_file_truncated
);
4062 /* Unhook NEXT from the chain. */
4063 entry
->next_entry
= next
->next_entry
;
4064 chain
->num_entries
--;
4065 if (chain
->num_entries
< 2)
4067 next
= next
->next_entry
;
4071 points_to_entry
= & entry
->next_entry
;
4073 next
= next
->next_entry
;
4078 chain
->last_entry
= entry
;
4083 /* Attach B's chain onto A. */
4085 rsrc_attach_chain (rsrc_dir_chain
* achain
, rsrc_dir_chain
* bchain
)
4087 if (bchain
->num_entries
== 0)
4090 achain
->num_entries
+= bchain
->num_entries
;
4092 if (achain
->first_entry
== NULL
)
4094 achain
->first_entry
= bchain
->first_entry
;
4095 achain
->last_entry
= bchain
->last_entry
;
4099 achain
->last_entry
->next_entry
= bchain
->first_entry
;
4100 achain
->last_entry
= bchain
->last_entry
;
4103 bchain
->num_entries
= 0;
4104 bchain
->first_entry
= bchain
->last_entry
= NULL
;
4108 rsrc_merge (struct rsrc_entry
* a
, struct rsrc_entry
* b
)
4110 rsrc_directory
* adir
;
4111 rsrc_directory
* bdir
;
4113 BFD_ASSERT (a
->is_dir
);
4114 BFD_ASSERT (b
->is_dir
);
4116 adir
= a
->value
.directory
;
4117 bdir
= b
->value
.directory
;
4119 if (adir
->characteristics
!= bdir
->characteristics
)
4121 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics"));
4122 bfd_set_error (bfd_error_file_truncated
);
4126 if (adir
->major
!= bdir
->major
|| adir
->minor
!= bdir
->minor
)
4128 _bfd_error_handler (_(".rsrc merge failure: differing directory versions"));
4129 bfd_set_error (bfd_error_file_truncated
);
4133 /* Attach B's name chain to A. */
4134 rsrc_attach_chain (& adir
->names
, & bdir
->names
);
4136 /* Attach B's ID chain to A. */
4137 rsrc_attach_chain (& adir
->ids
, & bdir
->ids
);
4139 /* Now sort A's entries. */
4140 rsrc_sort_entries (& adir
->names
, TRUE
, adir
);
4141 rsrc_sort_entries (& adir
->ids
, FALSE
, adir
);
4144 /* Check the .rsrc section. If it contains multiple concatenated
4145 resources then we must merge them properly. Otherwise Windows
4146 will ignore all but the first set. */
4149 rsrc_process_section (bfd
* abfd
,
4150 struct coff_final_link_info
* pfinfo
)
4152 rsrc_directory new_table
;
4158 bfd_byte
* datastart
;
4160 bfd_byte
* new_data
;
4161 unsigned int num_resource_sets
;
4162 rsrc_directory
* type_tables
;
4163 rsrc_write_data write_data
;
4166 unsigned int num_input_rsrc
= 0;
4167 unsigned int max_num_input_rsrc
= 4;
4168 ptrdiff_t * rsrc_sizes
= NULL
;
4170 new_table
.names
.num_entries
= 0;
4171 new_table
.ids
.num_entries
= 0;
4173 sec
= bfd_get_section_by_name (abfd
, ".rsrc");
4174 if (sec
== NULL
|| (size
= sec
->rawsize
) == 0)
4177 pe
= pe_data (abfd
);
4181 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4183 data
= bfd_malloc (size
);
4189 if (! bfd_get_section_contents (abfd
, sec
, data
, 0, size
))
4192 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4193 their lengths. Note - we rely upon the fact that the linker script
4194 does *not* sort the input .rsrc sections, so that the order in the
4195 linkinfo list matches the order in the output .rsrc section.
4197 We need to know the lengths because each input .rsrc section has padding
4198 at the end of a variable amount. (It does not appear to be based upon
4199 the section alignment or the file alignment). We need to skip any
4200 padding bytes when parsing the input .rsrc sections. */
4201 rsrc_sizes
= bfd_malloc (max_num_input_rsrc
* sizeof * rsrc_sizes
);
4202 if (rsrc_sizes
== NULL
)
4205 for (input
= pfinfo
->info
->input_bfds
;
4207 input
= input
->link
.next
)
4209 asection
* rsrc_sec
= bfd_get_section_by_name (input
, ".rsrc");
4211 /* PR 18372 - skip discarded .rsrc sections. */
4212 if (rsrc_sec
!= NULL
&& !discarded_section (rsrc_sec
))
4214 if (num_input_rsrc
== max_num_input_rsrc
)
4216 max_num_input_rsrc
+= 10;
4217 rsrc_sizes
= bfd_realloc (rsrc_sizes
, max_num_input_rsrc
4218 * sizeof * rsrc_sizes
);
4219 if (rsrc_sizes
== NULL
)
4223 BFD_ASSERT (rsrc_sec
->size
> 0);
4224 rsrc_sizes
[num_input_rsrc
++] = rsrc_sec
->size
;
4228 if (num_input_rsrc
< 2)
4231 /* Step one: Walk the section, computing the size of the tables,
4232 leaves and data and decide if we need to do anything. */
4233 dataend
= data
+ size
;
4234 num_resource_sets
= 0;
4236 while (data
< dataend
)
4238 bfd_byte
* p
= data
;
4240 data
= rsrc_count_directory (abfd
, data
, data
, dataend
, rva_bias
);
4244 /* Corrupted .rsrc section - cannot merge. */
4245 _bfd_error_handler (_("%pB: .rsrc merge failure: corrupt .rsrc section"),
4247 bfd_set_error (bfd_error_file_truncated
);
4251 if ((data
- p
) > rsrc_sizes
[num_resource_sets
])
4253 _bfd_error_handler (_("%pB: .rsrc merge failure: unexpected .rsrc size"),
4255 bfd_set_error (bfd_error_file_truncated
);
4258 /* FIXME: Should we add a check for "data - p" being much smaller
4259 than rsrc_sizes[num_resource_sets] ? */
4261 data
= p
+ rsrc_sizes
[num_resource_sets
];
4262 rva_bias
+= data
- p
;
4263 ++ num_resource_sets
;
4265 BFD_ASSERT (num_resource_sets
== num_input_rsrc
);
4267 /* Step two: Walk the data again, building trees of the resources. */
4269 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4271 type_tables
= bfd_malloc (num_resource_sets
* sizeof * type_tables
);
4272 if (type_tables
== NULL
)
4276 while (data
< dataend
)
4278 bfd_byte
* p
= data
;
4280 (void) rsrc_parse_directory (abfd
, type_tables
+ indx
, data
, data
,
4281 dataend
, rva_bias
, NULL
);
4282 data
= p
+ rsrc_sizes
[indx
];
4283 rva_bias
+= data
- p
;
4286 BFD_ASSERT (indx
== num_resource_sets
);
4288 /* Step three: Merge the top level tables (there can be only one).
4290 We must ensure that the merged entries are in ascending order.
4292 We also thread the top level table entries from the old tree onto
4293 the new table, so that they can be pulled off later. */
4295 /* FIXME: Should we verify that all type tables are the same ? */
4296 new_table
.characteristics
= type_tables
[0].characteristics
;
4297 new_table
.time
= type_tables
[0].time
;
4298 new_table
.major
= type_tables
[0].major
;
4299 new_table
.minor
= type_tables
[0].minor
;
4301 /* Chain the NAME entries onto the table. */
4302 new_table
.names
.first_entry
= NULL
;
4303 new_table
.names
.last_entry
= NULL
;
4305 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4306 rsrc_attach_chain (& new_table
.names
, & type_tables
[indx
].names
);
4308 rsrc_sort_entries (& new_table
.names
, TRUE
, & new_table
);
4310 /* Chain the ID entries onto the table. */
4311 new_table
.ids
.first_entry
= NULL
;
4312 new_table
.ids
.last_entry
= NULL
;
4314 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4315 rsrc_attach_chain (& new_table
.ids
, & type_tables
[indx
].ids
);
4317 rsrc_sort_entries (& new_table
.ids
, FALSE
, & new_table
);
4319 /* Step four: Create new contents for the .rsrc section. */
4320 /* Step four point one: Compute the size of each region of the .rsrc section.
4321 We do this now, rather than earlier, as the merging above may have dropped
4323 sizeof_leaves
= sizeof_strings
= sizeof_tables_and_entries
= 0;
4324 rsrc_compute_region_sizes (& new_table
);
4325 /* We increment sizeof_strings to make sure that resource data
4326 starts on an 8-byte boundary. FIXME: Is this correct ? */
4327 sizeof_strings
= (sizeof_strings
+ 7) & ~ 7;
4329 new_data
= bfd_zalloc (abfd
, size
);
4330 if (new_data
== NULL
)
4333 write_data
.abfd
= abfd
;
4334 write_data
.datastart
= new_data
;
4335 write_data
.next_table
= new_data
;
4336 write_data
.next_leaf
= new_data
+ sizeof_tables_and_entries
;
4337 write_data
.next_string
= write_data
.next_leaf
+ sizeof_leaves
;
4338 write_data
.next_data
= write_data
.next_string
+ sizeof_strings
;
4339 write_data
.rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4341 rsrc_write_directory (& write_data
, & new_table
);
4343 /* Step five: Replace the old contents with the new.
4344 We don't recompute the size as it's too late here to shrink section.
4345 See PR ld/20193 for more details. */
4346 bfd_set_section_contents (pfinfo
->output_bfd
, sec
, new_data
, 0, size
);
4347 sec
->size
= sec
->rawsize
= size
;
4350 /* Step six: Free all the memory that we have used. */
4351 /* FIXME: Free the resource tree, if we have one. */
4356 /* Handle the .idata section and other things that need symbol table
4360 _bfd_XXi_final_link_postscript (bfd
* abfd
, struct coff_final_link_info
*pfinfo
)
4362 struct coff_link_hash_entry
*h1
;
4363 struct bfd_link_info
*info
= pfinfo
->info
;
4364 bfd_boolean result
= TRUE
;
4366 /* There are a few fields that need to be filled in now while we
4367 have symbol table access.
4369 The .idata subsections aren't directly available as sections, but
4370 they are in the symbol table, so get them from there. */
4372 /* The import directory. This is the address of .idata$2, with size
4373 of .idata$2 + .idata$3. */
4374 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4375 ".idata$2", FALSE
, FALSE
, TRUE
);
4378 /* PR ld/2729: We cannot rely upon all the output sections having been
4379 created properly, so check before referencing them. Issue a warning
4380 message for any sections tht could not be found. */
4381 if ((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_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[1] because .idata$2 is missing"),
4397 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4398 ".idata$4", 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_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_TABLE
].VirtualAddress
);
4412 (_("%pB: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4417 /* The import address table. This is the size/address of
4419 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4420 ".idata$5", 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
)
4426 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4427 (h1
->root
.u
.def
.value
4428 + h1
->root
.u
.def
.section
->output_section
->vma
4429 + h1
->root
.u
.def
.section
->output_offset
);
4433 (_("%pB: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4438 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4439 ".idata$6", FALSE
, FALSE
, TRUE
);
4441 && (h1
->root
.type
== bfd_link_hash_defined
4442 || h1
->root
.type
== bfd_link_hash_defweak
)
4443 && h1
->root
.u
.def
.section
!= NULL
4444 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4445 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4446 ((h1
->root
.u
.def
.value
4447 + h1
->root
.u
.def
.section
->output_section
->vma
4448 + h1
->root
.u
.def
.section
->output_offset
)
4449 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
);
4453 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4460 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4461 "__IAT_start__", FALSE
, FALSE
, TRUE
);
4463 && (h1
->root
.type
== bfd_link_hash_defined
4464 || h1
->root
.type
== bfd_link_hash_defweak
)
4465 && h1
->root
.u
.def
.section
!= NULL
4466 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4471 (h1
->root
.u
.def
.value
4472 + h1
->root
.u
.def
.section
->output_section
->vma
4473 + h1
->root
.u
.def
.section
->output_offset
);
4475 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4476 "__IAT_end__", FALSE
, FALSE
, TRUE
);
4478 && (h1
->root
.type
== bfd_link_hash_defined
4479 || h1
->root
.type
== bfd_link_hash_defweak
)
4480 && h1
->root
.u
.def
.section
!= NULL
4481 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4483 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4484 ((h1
->root
.u
.def
.value
4485 + h1
->root
.u
.def
.section
->output_section
->vma
4486 + h1
->root
.u
.def
.section
->output_offset
)
4488 if (pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
!= 0)
4489 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4490 iat_va
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
4495 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4496 " because .idata$6 is missing"), abfd
);
4502 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4503 (bfd_get_symbol_leading_char (abfd
) != 0
4504 ? "__tls_used" : "_tls_used"),
4505 FALSE
, FALSE
, TRUE
);
4508 if ((h1
->root
.type
== bfd_link_hash_defined
4509 || h1
->root
.type
== bfd_link_hash_defweak
)
4510 && h1
->root
.u
.def
.section
!= NULL
4511 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4512 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].VirtualAddress
=
4513 (h1
->root
.u
.def
.value
4514 + h1
->root
.u
.def
.section
->output_section
->vma
4515 + h1
->root
.u
.def
.section
->output_offset
4516 - pe_data (abfd
)->pe_opthdr
.ImageBase
);
4520 (_("%pB: unable to fill in DataDictionary[9] because __tls_used is missing"),
4524 /* According to PECOFF sepcifications by Microsoft version 8.2
4525 the TLS data directory consists of 4 pointers, followed
4526 by two 4-byte integer. This implies that the total size
4527 is different for 32-bit and 64-bit executables. */
4528 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4529 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x18;
4531 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x28;
4535 /* If there is a .pdata section and we have linked pdata finally, we
4536 need to sort the entries ascending. */
4537 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4539 asection
*sec
= bfd_get_section_by_name (abfd
, ".pdata");
4543 bfd_size_type x
= sec
->rawsize
;
4544 bfd_byte
*tmp_data
= NULL
;
4547 tmp_data
= bfd_malloc (x
);
4549 if (tmp_data
!= NULL
)
4551 if (bfd_get_section_contents (abfd
, sec
, tmp_data
, 0, x
))
4555 12, sort_x64_pdata
);
4556 bfd_set_section_contents (pfinfo
->output_bfd
, sec
,
4567 rsrc_process_section (abfd
, pfinfo
);
4569 /* If we couldn't find idata$2, we either have an excessively
4570 trivial program or are in DEEP trouble; we have to assume trivial