1 /* Support for the generic parts of PE/PEI; the common executable parts.
2 Copyright (C) 1995-2020 Free Software Foundation, Inc.
3 Written by Cygnus Solutions.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
23 /* Most of this hacked by Steve Chamberlain <sac@cygnus.com>.
25 PE/PEI rearrangement (and code added): Donn Terry
26 Softway Systems, Inc. */
28 /* Hey look, some documentation [and in a place you expect to find it]!
30 The main reference for the pei format is "Microsoft Portable Executable
31 and Common Object File Format Specification 4.1". Get it if you need to
32 do some serious hacking on this code.
35 "Peering Inside the PE: A Tour of the Win32 Portable Executable
36 File Format", MSJ 1994, Volume 9.
38 The PE/PEI format is also used by .NET. ECMA-335 describes this:
40 "Standard ECMA-335 Common Language Infrastructure (CLI)", 6th Edition, June 2012.
42 This is also available at
43 https://www.ecma-international.org/publications/files/ECMA-ST/ECMA-335.pdf.
45 The *sole* difference between the pe format and the pei format is that the
46 latter has an MSDOS 2.0 .exe header on the front that prints the message
47 "This app must be run under Windows." (or some such).
48 (FIXME: Whether that statement is *really* true or not is unknown.
49 Are there more subtle differences between pe and pei formats?
50 For now assume there aren't. If you find one, then for God sakes
53 The Microsoft docs use the word "image" instead of "executable" because
54 the former can also refer to a DLL (shared library). Confusion can arise
55 because the `i' in `pei' also refers to "image". The `pe' format can
56 also create images (i.e. executables), it's just that to run on a win32
57 system you need to use the pei format.
59 FIXME: Please add more docs here so the next poor fool that has to hack
60 on this code has a chance of getting something accomplished without
61 wasting too much time. */
63 /* This expands into COFF_WITH_pe, COFF_WITH_pep, or COFF_WITH_pex64
64 depending on whether we're compiling for straight PE or PE+. */
70 #include "coff/internal.h"
72 #include "libiberty.h"
80 /* NOTE: it's strange to be including an architecture specific header
81 in what's supposed to be general (to PE/PEI) code. However, that's
82 where the definitions are, and they don't vary per architecture
83 within PE/PEI, so we get them from there. FIXME: The lack of
84 variance is an assumption which may prove to be incorrect if new
85 PE/PEI targets are created. */
86 #if defined COFF_WITH_pex64
87 # include "coff/x86_64.h"
88 #elif defined COFF_WITH_pep
89 # include "coff/ia64.h"
91 # include "coff/i386.h"
97 #include "safe-ctype.h"
99 #if defined COFF_WITH_pep || defined COFF_WITH_pex64
101 # define AOUTSZ PEPAOUTSZ
102 # define PEAOUTHDR PEPAOUTHDR
105 #define HighBitSet(val) ((val) & 0x80000000)
106 #define SetHighBit(val) ((val) | 0x80000000)
107 #define WithoutHighBit(val) ((val) & 0x7fffffff)
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
);
729 /* The first non-zero section filepos is the header size.
730 Sections without contents will have a filepos of 0. */
732 hsize
= sec
->filepos
;
733 if (sec
->flags
& SEC_DATA
)
735 if (sec
->flags
& SEC_CODE
)
737 /* The image size is the total VIRTUAL size (which is what is
738 in the virt_size field). Files have been seen (from MSVC
739 5.0 link.exe) where the file size of the .data segment is
740 quite small compared to the virtual size. Without this
741 fix, strip munges the file.
743 FIXME: We need to handle holes between sections, which may
744 happpen when we covert from another format. We just use
745 the virtual address and virtual size of the last section
746 for the image size. */
747 if (coff_section_data (abfd
, sec
) != NULL
748 && pei_section_data (abfd
, sec
) != NULL
)
749 isize
= (sec
->vma
- extra
->ImageBase
750 + SA (FA (pei_section_data (abfd
, sec
)->virt_size
)));
753 aouthdr_in
->dsize
= dsize
;
754 aouthdr_in
->tsize
= tsize
;
755 extra
->SizeOfHeaders
= hsize
;
756 extra
->SizeOfImage
= isize
;
759 H_PUT_16 (abfd
, aouthdr_in
->magic
, aouthdr_out
->standard
.magic
);
761 /* e.g. 219510000 is linker version 2.19 */
762 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
764 /* This piece of magic sets the "linker version" field to
766 H_PUT_16 (abfd
, (LINKER_VERSION
/ 100 + (LINKER_VERSION
% 100) * 256),
767 aouthdr_out
->standard
.vstamp
);
769 PUT_AOUTHDR_TSIZE (abfd
, aouthdr_in
->tsize
, aouthdr_out
->standard
.tsize
);
770 PUT_AOUTHDR_DSIZE (abfd
, aouthdr_in
->dsize
, aouthdr_out
->standard
.dsize
);
771 PUT_AOUTHDR_BSIZE (abfd
, aouthdr_in
->bsize
, aouthdr_out
->standard
.bsize
);
772 PUT_AOUTHDR_ENTRY (abfd
, aouthdr_in
->entry
, aouthdr_out
->standard
.entry
);
773 PUT_AOUTHDR_TEXT_START (abfd
, aouthdr_in
->text_start
,
774 aouthdr_out
->standard
.text_start
);
776 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
777 /* PE32+ does not have data_start member! */
778 PUT_AOUTHDR_DATA_START (abfd
, aouthdr_in
->data_start
,
779 aouthdr_out
->standard
.data_start
);
782 PUT_OPTHDR_IMAGE_BASE (abfd
, extra
->ImageBase
, aouthdr_out
->ImageBase
);
783 H_PUT_32 (abfd
, extra
->SectionAlignment
, aouthdr_out
->SectionAlignment
);
784 H_PUT_32 (abfd
, extra
->FileAlignment
, aouthdr_out
->FileAlignment
);
785 H_PUT_16 (abfd
, extra
->MajorOperatingSystemVersion
,
786 aouthdr_out
->MajorOperatingSystemVersion
);
787 H_PUT_16 (abfd
, extra
->MinorOperatingSystemVersion
,
788 aouthdr_out
->MinorOperatingSystemVersion
);
789 H_PUT_16 (abfd
, extra
->MajorImageVersion
, aouthdr_out
->MajorImageVersion
);
790 H_PUT_16 (abfd
, extra
->MinorImageVersion
, aouthdr_out
->MinorImageVersion
);
791 H_PUT_16 (abfd
, extra
->MajorSubsystemVersion
,
792 aouthdr_out
->MajorSubsystemVersion
);
793 H_PUT_16 (abfd
, extra
->MinorSubsystemVersion
,
794 aouthdr_out
->MinorSubsystemVersion
);
795 H_PUT_32 (abfd
, extra
->Reserved1
, aouthdr_out
->Reserved1
);
796 H_PUT_32 (abfd
, extra
->SizeOfImage
, aouthdr_out
->SizeOfImage
);
797 H_PUT_32 (abfd
, extra
->SizeOfHeaders
, aouthdr_out
->SizeOfHeaders
);
798 H_PUT_32 (abfd
, extra
->CheckSum
, aouthdr_out
->CheckSum
);
799 H_PUT_16 (abfd
, extra
->Subsystem
, aouthdr_out
->Subsystem
);
800 H_PUT_16 (abfd
, extra
->DllCharacteristics
, aouthdr_out
->DllCharacteristics
);
801 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd
, extra
->SizeOfStackReserve
,
802 aouthdr_out
->SizeOfStackReserve
);
803 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd
, extra
->SizeOfStackCommit
,
804 aouthdr_out
->SizeOfStackCommit
);
805 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd
, extra
->SizeOfHeapReserve
,
806 aouthdr_out
->SizeOfHeapReserve
);
807 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd
, extra
->SizeOfHeapCommit
,
808 aouthdr_out
->SizeOfHeapCommit
);
809 H_PUT_32 (abfd
, extra
->LoaderFlags
, aouthdr_out
->LoaderFlags
);
810 H_PUT_32 (abfd
, extra
->NumberOfRvaAndSizes
,
811 aouthdr_out
->NumberOfRvaAndSizes
);
815 for (idx
= 0; idx
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; idx
++)
817 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].VirtualAddress
,
818 aouthdr_out
->DataDirectory
[idx
][0]);
819 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].Size
,
820 aouthdr_out
->DataDirectory
[idx
][1]);
828 _bfd_XXi_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
831 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
832 struct external_PEI_filehdr
*filehdr_out
= (struct external_PEI_filehdr
*) out
;
834 if (pe_data (abfd
)->has_reloc_section
835 || pe_data (abfd
)->dont_strip_reloc
)
836 filehdr_in
->f_flags
&= ~F_RELFLG
;
838 if (pe_data (abfd
)->dll
)
839 filehdr_in
->f_flags
|= F_DLL
;
841 filehdr_in
->pe
.e_magic
= IMAGE_DOS_SIGNATURE
;
842 filehdr_in
->pe
.e_cblp
= 0x90;
843 filehdr_in
->pe
.e_cp
= 0x3;
844 filehdr_in
->pe
.e_crlc
= 0x0;
845 filehdr_in
->pe
.e_cparhdr
= 0x4;
846 filehdr_in
->pe
.e_minalloc
= 0x0;
847 filehdr_in
->pe
.e_maxalloc
= 0xffff;
848 filehdr_in
->pe
.e_ss
= 0x0;
849 filehdr_in
->pe
.e_sp
= 0xb8;
850 filehdr_in
->pe
.e_csum
= 0x0;
851 filehdr_in
->pe
.e_ip
= 0x0;
852 filehdr_in
->pe
.e_cs
= 0x0;
853 filehdr_in
->pe
.e_lfarlc
= 0x40;
854 filehdr_in
->pe
.e_ovno
= 0x0;
856 for (idx
= 0; idx
< 4; idx
++)
857 filehdr_in
->pe
.e_res
[idx
] = 0x0;
859 filehdr_in
->pe
.e_oemid
= 0x0;
860 filehdr_in
->pe
.e_oeminfo
= 0x0;
862 for (idx
= 0; idx
< 10; idx
++)
863 filehdr_in
->pe
.e_res2
[idx
] = 0x0;
865 filehdr_in
->pe
.e_lfanew
= 0x80;
867 /* This next collection of data are mostly just characters. It
868 appears to be constant within the headers put on NT exes. */
869 memcpy (filehdr_in
->pe
.dos_message
, pe_data (abfd
)->dos_message
,
870 sizeof (filehdr_in
->pe
.dos_message
));
872 filehdr_in
->pe
.nt_signature
= IMAGE_NT_SIGNATURE
;
874 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
875 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
877 /* Use a real timestamp by default, unless the no-insert-timestamp
878 option was chosen. */
879 if ((pe_data (abfd
)->insert_timestamp
))
880 H_PUT_32 (abfd
, time (0), filehdr_out
->f_timdat
);
882 H_PUT_32 (abfd
, 0, filehdr_out
->f_timdat
);
884 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
885 filehdr_out
->f_symptr
);
886 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
887 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
888 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
890 /* Put in extra dos header stuff. This data remains essentially
891 constant, it just has to be tacked on to the beginning of all exes
893 H_PUT_16 (abfd
, filehdr_in
->pe
.e_magic
, filehdr_out
->e_magic
);
894 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cblp
, filehdr_out
->e_cblp
);
895 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cp
, filehdr_out
->e_cp
);
896 H_PUT_16 (abfd
, filehdr_in
->pe
.e_crlc
, filehdr_out
->e_crlc
);
897 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cparhdr
, filehdr_out
->e_cparhdr
);
898 H_PUT_16 (abfd
, filehdr_in
->pe
.e_minalloc
, filehdr_out
->e_minalloc
);
899 H_PUT_16 (abfd
, filehdr_in
->pe
.e_maxalloc
, filehdr_out
->e_maxalloc
);
900 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ss
, filehdr_out
->e_ss
);
901 H_PUT_16 (abfd
, filehdr_in
->pe
.e_sp
, filehdr_out
->e_sp
);
902 H_PUT_16 (abfd
, filehdr_in
->pe
.e_csum
, filehdr_out
->e_csum
);
903 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ip
, filehdr_out
->e_ip
);
904 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cs
, filehdr_out
->e_cs
);
905 H_PUT_16 (abfd
, filehdr_in
->pe
.e_lfarlc
, filehdr_out
->e_lfarlc
);
906 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ovno
, filehdr_out
->e_ovno
);
908 for (idx
= 0; idx
< 4; idx
++)
909 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res
[idx
], filehdr_out
->e_res
[idx
]);
911 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oemid
, filehdr_out
->e_oemid
);
912 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oeminfo
, filehdr_out
->e_oeminfo
);
914 for (idx
= 0; idx
< 10; idx
++)
915 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res2
[idx
], filehdr_out
->e_res2
[idx
]);
917 H_PUT_32 (abfd
, filehdr_in
->pe
.e_lfanew
, filehdr_out
->e_lfanew
);
919 for (idx
= 0; idx
< 16; idx
++)
920 H_PUT_32 (abfd
, filehdr_in
->pe
.dos_message
[idx
],
921 filehdr_out
->dos_message
[idx
]);
923 /* Also put in the NT signature. */
924 H_PUT_32 (abfd
, filehdr_in
->pe
.nt_signature
, filehdr_out
->nt_signature
);
930 _bfd_XX_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
932 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
933 FILHDR
*filehdr_out
= (FILHDR
*) out
;
935 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
936 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
937 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->f_timdat
);
938 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
, filehdr_out
->f_symptr
);
939 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
940 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
941 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
947 _bfd_XXi_swap_scnhdr_out (bfd
* abfd
, void * in
, void * out
)
949 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*) in
;
950 SCNHDR
*scnhdr_ext
= (SCNHDR
*) out
;
951 unsigned int ret
= SCNHSZ
;
955 memcpy (scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof (scnhdr_int
->s_name
));
957 PUT_SCNHDR_VADDR (abfd
,
958 ((scnhdr_int
->s_vaddr
959 - pe_data (abfd
)->pe_opthdr
.ImageBase
)
961 scnhdr_ext
->s_vaddr
);
963 /* NT wants the size data to be rounded up to the next
964 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
966 if ((scnhdr_int
->s_flags
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
) != 0)
968 if (bfd_pei_p (abfd
))
970 ps
= scnhdr_int
->s_size
;
976 ss
= scnhdr_int
->s_size
;
981 if (bfd_pei_p (abfd
))
982 ps
= scnhdr_int
->s_paddr
;
986 ss
= scnhdr_int
->s_size
;
989 PUT_SCNHDR_SIZE (abfd
, ss
,
992 /* s_paddr in PE is really the virtual size. */
993 PUT_SCNHDR_PADDR (abfd
, ps
, scnhdr_ext
->s_paddr
);
995 PUT_SCNHDR_SCNPTR (abfd
, scnhdr_int
->s_scnptr
,
996 scnhdr_ext
->s_scnptr
);
997 PUT_SCNHDR_RELPTR (abfd
, scnhdr_int
->s_relptr
,
998 scnhdr_ext
->s_relptr
);
999 PUT_SCNHDR_LNNOPTR (abfd
, scnhdr_int
->s_lnnoptr
,
1000 scnhdr_ext
->s_lnnoptr
);
1003 /* Extra flags must be set when dealing with PE. All sections should also
1004 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
1005 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
1006 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
1007 (this is especially important when dealing with the .idata section since
1008 the addresses for routines from .dlls must be overwritten). If .reloc
1009 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
1010 (0x02000000). Also, the resource data should also be read and
1013 /* FIXME: Alignment is also encoded in this field, at least on PPC and
1014 ARM-WINCE. Although - how do we get the original alignment field
1019 char section_name
[SCNNMLEN
];
1020 unsigned long must_have
;
1022 pe_required_section_flags
;
1024 pe_required_section_flags known_sections
[] =
1026 { ".arch", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
| IMAGE_SCN_ALIGN_8BYTES
},
1027 { ".bss", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1028 { ".data", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1029 { ".edata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1030 { ".idata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1031 { ".pdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1032 { ".rdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1033 { ".reloc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
},
1034 { ".rsrc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1035 { ".text" , IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_CODE
| IMAGE_SCN_MEM_EXECUTE
},
1036 { ".tls", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1037 { ".xdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1040 pe_required_section_flags
* p
;
1042 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1043 we know exactly what this specific section wants so we remove it
1044 and then allow the must_have field to add it back in if necessary.
1045 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1046 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
1047 by ld --enable-auto-import (if auto-import is actually needed),
1048 by ld --omagic, or by obcopy --writable-text. */
1050 for (p
= known_sections
;
1051 p
< known_sections
+ ARRAY_SIZE (known_sections
);
1053 if (memcmp (scnhdr_int
->s_name
, p
->section_name
, SCNNMLEN
) == 0)
1055 if (memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text")
1056 || (bfd_get_file_flags (abfd
) & WP_TEXT
))
1057 scnhdr_int
->s_flags
&= ~IMAGE_SCN_MEM_WRITE
;
1058 scnhdr_int
->s_flags
|= p
->must_have
;
1062 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1065 if (coff_data (abfd
)->link_info
1066 && ! bfd_link_relocatable (coff_data (abfd
)->link_info
)
1067 && ! bfd_link_pic (coff_data (abfd
)->link_info
)
1068 && memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text") == 0)
1070 /* By inference from looking at MS output, the 32 bit field
1071 which is the combination of the number_of_relocs and
1072 number_of_linenos is used for the line number count in
1073 executables. A 16-bit field won't do for cc1. The MS
1074 document says that the number of relocs is zero for
1075 executables, but the 17-th bit has been observed to be there.
1076 Overflow is not an issue: a 4G-line program will overflow a
1077 bunch of other fields long before this! */
1078 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
& 0xffff), scnhdr_ext
->s_nlnno
);
1079 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
>> 16), scnhdr_ext
->s_nreloc
);
1083 if (scnhdr_int
->s_nlnno
<= 0xffff)
1084 H_PUT_16 (abfd
, scnhdr_int
->s_nlnno
, scnhdr_ext
->s_nlnno
);
1087 /* xgettext:c-format */
1088 _bfd_error_handler (_("%pB: line number overflow: 0x%lx > 0xffff"),
1089 abfd
, scnhdr_int
->s_nlnno
);
1090 bfd_set_error (bfd_error_file_truncated
);
1091 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nlnno
);
1095 /* Although we could encode 0xffff relocs here, we do not, to be
1096 consistent with other parts of bfd. Also it lets us warn, as
1097 we should never see 0xffff here w/o having the overflow flag
1099 if (scnhdr_int
->s_nreloc
< 0xffff)
1100 H_PUT_16 (abfd
, scnhdr_int
->s_nreloc
, scnhdr_ext
->s_nreloc
);
1103 /* PE can deal with large #s of relocs, but not here. */
1104 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nreloc
);
1105 scnhdr_int
->s_flags
|= IMAGE_SCN_LNK_NRELOC_OVFL
;
1106 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1113 _bfd_XXi_swap_debugdir_in (bfd
* abfd
, void * ext1
, void * in1
)
1115 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) ext1
;
1116 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) in1
;
1118 in
->Characteristics
= H_GET_32(abfd
, ext
->Characteristics
);
1119 in
->TimeDateStamp
= H_GET_32(abfd
, ext
->TimeDateStamp
);
1120 in
->MajorVersion
= H_GET_16(abfd
, ext
->MajorVersion
);
1121 in
->MinorVersion
= H_GET_16(abfd
, ext
->MinorVersion
);
1122 in
->Type
= H_GET_32(abfd
, ext
->Type
);
1123 in
->SizeOfData
= H_GET_32(abfd
, ext
->SizeOfData
);
1124 in
->AddressOfRawData
= H_GET_32(abfd
, ext
->AddressOfRawData
);
1125 in
->PointerToRawData
= H_GET_32(abfd
, ext
->PointerToRawData
);
1129 _bfd_XXi_swap_debugdir_out (bfd
* abfd
, void * inp
, void * extp
)
1131 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) extp
;
1132 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) inp
;
1134 H_PUT_32(abfd
, in
->Characteristics
, ext
->Characteristics
);
1135 H_PUT_32(abfd
, in
->TimeDateStamp
, ext
->TimeDateStamp
);
1136 H_PUT_16(abfd
, in
->MajorVersion
, ext
->MajorVersion
);
1137 H_PUT_16(abfd
, in
->MinorVersion
, ext
->MinorVersion
);
1138 H_PUT_32(abfd
, in
->Type
, ext
->Type
);
1139 H_PUT_32(abfd
, in
->SizeOfData
, ext
->SizeOfData
);
1140 H_PUT_32(abfd
, in
->AddressOfRawData
, ext
->AddressOfRawData
);
1141 H_PUT_32(abfd
, in
->PointerToRawData
, ext
->PointerToRawData
);
1143 return sizeof (struct external_IMAGE_DEBUG_DIRECTORY
);
1147 _bfd_XXi_slurp_codeview_record (bfd
* abfd
, file_ptr where
, unsigned long length
, CODEVIEW_INFO
*cvinfo
)
1151 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1154 if (bfd_bread (buffer
, 256, abfd
) < 4)
1157 /* Ensure null termination of filename. */
1160 cvinfo
->CVSignature
= H_GET_32 (abfd
, buffer
);
1163 if ((cvinfo
->CVSignature
== CVINFO_PDB70_CVSIGNATURE
)
1164 && (length
> sizeof (CV_INFO_PDB70
)))
1166 CV_INFO_PDB70
*cvinfo70
= (CV_INFO_PDB70
*)(buffer
);
1168 cvinfo
->Age
= H_GET_32(abfd
, cvinfo70
->Age
);
1170 /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1171 by 8 single bytes. Byte swap them so we can conveniently treat the GUID
1172 as 16 bytes in big-endian order. */
1173 bfd_putb32 (bfd_getl32 (cvinfo70
->Signature
), cvinfo
->Signature
);
1174 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[4])), &(cvinfo
->Signature
[4]));
1175 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[6])), &(cvinfo
->Signature
[6]));
1176 memcpy (&(cvinfo
->Signature
[8]), &(cvinfo70
->Signature
[8]), 8);
1178 cvinfo
->SignatureLength
= CV_INFO_SIGNATURE_LENGTH
;
1179 // cvinfo->PdbFileName = cvinfo70->PdbFileName;
1183 else if ((cvinfo
->CVSignature
== CVINFO_PDB20_CVSIGNATURE
)
1184 && (length
> sizeof (CV_INFO_PDB20
)))
1186 CV_INFO_PDB20
*cvinfo20
= (CV_INFO_PDB20
*)(buffer
);
1187 cvinfo
->Age
= H_GET_32(abfd
, cvinfo20
->Age
);
1188 memcpy (cvinfo
->Signature
, cvinfo20
->Signature
, 4);
1189 cvinfo
->SignatureLength
= 4;
1190 // cvinfo->PdbFileName = cvinfo20->PdbFileName;
1199 _bfd_XXi_write_codeview_record (bfd
* abfd
, file_ptr where
, CODEVIEW_INFO
*cvinfo
)
1201 const bfd_size_type size
= sizeof (CV_INFO_PDB70
) + 1;
1202 bfd_size_type written
;
1203 CV_INFO_PDB70
*cvinfo70
;
1206 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1209 buffer
= bfd_malloc (size
);
1213 cvinfo70
= (CV_INFO_PDB70
*) buffer
;
1214 H_PUT_32 (abfd
, CVINFO_PDB70_CVSIGNATURE
, cvinfo70
->CvSignature
);
1216 /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1217 in little-endian order, followed by 8 single bytes. */
1218 bfd_putl32 (bfd_getb32 (cvinfo
->Signature
), cvinfo70
->Signature
);
1219 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[4])), &(cvinfo70
->Signature
[4]));
1220 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[6])), &(cvinfo70
->Signature
[6]));
1221 memcpy (&(cvinfo70
->Signature
[8]), &(cvinfo
->Signature
[8]), 8);
1223 H_PUT_32 (abfd
, cvinfo
->Age
, cvinfo70
->Age
);
1224 cvinfo70
->PdbFileName
[0] = '\0';
1226 written
= bfd_bwrite (buffer
, size
, abfd
);
1230 return written
== size
? size
: 0;
1233 static char * dir_names
[IMAGE_NUMBEROF_DIRECTORY_ENTRIES
] =
1235 N_("Export Directory [.edata (or where ever we found it)]"),
1236 N_("Import Directory [parts of .idata]"),
1237 N_("Resource Directory [.rsrc]"),
1238 N_("Exception Directory [.pdata]"),
1239 N_("Security Directory"),
1240 N_("Base Relocation Directory [.reloc]"),
1241 N_("Debug Directory"),
1242 N_("Description Directory"),
1243 N_("Special Directory"),
1244 N_("Thread Storage Directory [.tls]"),
1245 N_("Load Configuration Directory"),
1246 N_("Bound Import Directory"),
1247 N_("Import Address Table Directory"),
1248 N_("Delay Import Directory"),
1249 N_("CLR Runtime Header"),
1253 #ifdef POWERPC_LE_PE
1254 /* The code for the PPC really falls in the "architecture dependent"
1255 category. However, it's not clear that anyone will ever care, so
1256 we're ignoring the issue for now; if/when PPC matters, some of this
1257 may need to go into peicode.h, or arguments passed to enable the
1258 PPC- specific code. */
1262 pe_print_idata (bfd
* abfd
, void * vfile
)
1264 FILE *file
= (FILE *) vfile
;
1269 #ifdef POWERPC_LE_PE
1270 asection
*rel_section
= bfd_get_section_by_name (abfd
, ".reldata");
1273 bfd_size_type datasize
= 0;
1274 bfd_size_type dataoff
;
1278 pe_data_type
*pe
= pe_data (abfd
);
1279 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1283 addr
= extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
;
1285 if (addr
== 0 && extra
->DataDirectory
[PE_IMPORT_TABLE
].Size
== 0)
1287 /* Maybe the extra header isn't there. Look for the section. */
1288 section
= bfd_get_section_by_name (abfd
, ".idata");
1289 if (section
== NULL
)
1292 addr
= section
->vma
;
1293 datasize
= section
->size
;
1299 addr
+= extra
->ImageBase
;
1300 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1302 datasize
= section
->size
;
1303 if (addr
>= section
->vma
&& addr
< section
->vma
+ datasize
)
1307 if (section
== NULL
)
1310 _("\nThere is an import table, but the section containing it could not be found\n"));
1313 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1316 _("\nThere is an import table in %s, but that section has no contents\n"),
1322 /* xgettext:c-format */
1323 fprintf (file
, _("\nThere is an import table in %s at 0x%lx\n"),
1324 section
->name
, (unsigned long) addr
);
1326 dataoff
= addr
- section
->vma
;
1328 #ifdef POWERPC_LE_PE
1329 if (rel_section
!= 0 && rel_section
->size
!= 0)
1331 /* The toc address can be found by taking the starting address,
1332 which on the PPC locates a function descriptor. The
1333 descriptor consists of the function code starting address
1334 followed by the address of the toc. The starting address we
1335 get from the bfd, and the descriptor is supposed to be in the
1336 .reldata section. */
1338 bfd_vma loadable_toc_address
;
1339 bfd_vma toc_address
;
1340 bfd_vma start_address
;
1344 if (!bfd_malloc_and_get_section (abfd
, rel_section
, &data
))
1351 offset
= abfd
->start_address
- rel_section
->vma
;
1353 if (offset
>= rel_section
->size
|| offset
+ 8 > rel_section
->size
)
1360 start_address
= bfd_get_32 (abfd
, data
+ offset
);
1361 loadable_toc_address
= bfd_get_32 (abfd
, data
+ offset
+ 4);
1362 toc_address
= loadable_toc_address
- 32768;
1365 _("\nFunction descriptor located at the start address: %04lx\n"),
1366 (unsigned long int) (abfd
->start_address
));
1368 /* xgettext:c-format */
1369 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1370 start_address
, loadable_toc_address
, toc_address
);
1377 _("\nNo reldata section! Function descriptor not decoded.\n"));
1382 _("\nThe Import Tables (interpreted %s section contents)\n"),
1386 vma: Hint Time Forward DLL First\n\
1387 Table Stamp Chain Name Thunk\n"));
1389 /* Read the whole section. Some of the fields might be before dataoff. */
1390 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
1397 adj
= section
->vma
- extra
->ImageBase
;
1399 /* Print all image import descriptors. */
1400 for (i
= dataoff
; i
+ onaline
<= datasize
; i
+= onaline
)
1404 bfd_vma forward_chain
;
1406 bfd_vma first_thunk
;
1411 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1412 fprintf (file
, " %08lx\t", (unsigned long) (i
+ adj
));
1413 hint_addr
= bfd_get_32 (abfd
, data
+ i
);
1414 time_stamp
= bfd_get_32 (abfd
, data
+ i
+ 4);
1415 forward_chain
= bfd_get_32 (abfd
, data
+ i
+ 8);
1416 dll_name
= bfd_get_32 (abfd
, data
+ i
+ 12);
1417 first_thunk
= bfd_get_32 (abfd
, data
+ i
+ 16);
1419 fprintf (file
, "%08lx %08lx %08lx %08lx %08lx\n",
1420 (unsigned long) hint_addr
,
1421 (unsigned long) time_stamp
,
1422 (unsigned long) forward_chain
,
1423 (unsigned long) dll_name
,
1424 (unsigned long) first_thunk
);
1426 if (hint_addr
== 0 && first_thunk
== 0)
1429 if (dll_name
- adj
>= section
->size
)
1432 dll
= (char *) data
+ dll_name
- adj
;
1433 /* PR 17512 file: 078-12277-0.004. */
1434 bfd_size_type maxlen
= (char *)(data
+ datasize
) - dll
- 1;
1435 fprintf (file
, _("\n\tDLL Name: %.*s\n"), (int) maxlen
, dll
);
1437 /* PR 21546: When the Hint Address is zero,
1438 we try the First Thunk instead. */
1440 hint_addr
= first_thunk
;
1442 if (hint_addr
!= 0 && hint_addr
- adj
< datasize
)
1445 asection
*ft_section
;
1447 bfd_size_type ft_datasize
;
1451 fprintf (file
, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1453 idx
= hint_addr
- adj
;
1455 ft_addr
= first_thunk
+ extra
->ImageBase
;
1456 ft_idx
= first_thunk
- adj
;
1457 ft_data
= data
+ ft_idx
;
1458 ft_datasize
= datasize
- ft_idx
;
1461 if (first_thunk
!= hint_addr
)
1463 /* Find the section which contains the first thunk. */
1464 for (ft_section
= abfd
->sections
;
1466 ft_section
= ft_section
->next
)
1468 if (ft_addr
>= ft_section
->vma
1469 && ft_addr
< ft_section
->vma
+ ft_section
->size
)
1473 if (ft_section
== NULL
)
1476 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1480 /* Now check to see if this section is the same as our current
1481 section. If it is not then we will have to load its data in. */
1482 if (ft_section
!= section
)
1484 ft_idx
= first_thunk
- (ft_section
->vma
- extra
->ImageBase
);
1485 ft_datasize
= ft_section
->size
- ft_idx
;
1486 ft_data
= (bfd_byte
*) bfd_malloc (ft_datasize
);
1487 if (ft_data
== NULL
)
1490 /* Read ft_datasize bytes starting at offset ft_idx. */
1491 if (!bfd_get_section_contents (abfd
, ft_section
, ft_data
,
1492 (bfd_vma
) ft_idx
, ft_datasize
))
1501 /* Print HintName vector entries. */
1502 #ifdef COFF_WITH_pex64
1503 for (j
= 0; idx
+ j
+ 8 <= datasize
; j
+= 8)
1506 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1507 unsigned long member_high
= bfd_get_32 (abfd
, data
+ idx
+ j
+ 4);
1509 if (!member
&& !member_high
)
1514 if (HighBitSet (member_high
))
1515 fprintf (file
, "\t%lx%08lx\t %4lx%08lx <none>",
1516 member_high
, member
,
1517 WithoutHighBit (member_high
), member
);
1518 /* PR binutils/17512: Handle corrupt PE data. */
1519 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1520 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1526 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1527 member_name
= (char *) data
+ amt
+ 2;
1528 fprintf (file
, "\t%04lx\t %4d %.*s",member
, ordinal
,
1529 (int) (datasize
- (amt
+ 2)), member_name
);
1532 /* If the time stamp is not zero, the import address
1533 table holds actual addresses. */
1536 && first_thunk
!= hint_addr
1537 && j
+ 4 <= ft_datasize
)
1538 fprintf (file
, "\t%04lx",
1539 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1540 fprintf (file
, "\n");
1543 for (j
= 0; idx
+ j
+ 4 <= datasize
; j
+= 4)
1546 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1548 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1554 if (HighBitSet (member
))
1555 fprintf (file
, "\t%04lx\t %4lu <none>",
1556 member
, WithoutHighBit (member
));
1557 /* PR binutils/17512: Handle corrupt PE data. */
1558 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1559 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1565 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1566 member_name
= (char *) data
+ amt
+ 2;
1567 fprintf (file
, "\t%04lx\t %4d %.*s",
1569 (int) (datasize
- (amt
+ 2)), member_name
);
1572 /* If the time stamp is not zero, the import address
1573 table holds actual addresses. */
1576 && first_thunk
!= hint_addr
1577 && j
+ 4 <= ft_datasize
)
1578 fprintf (file
, "\t%04lx",
1579 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1581 fprintf (file
, "\n");
1588 fprintf (file
, "\n");
1597 pe_print_edata (bfd
* abfd
, void * vfile
)
1599 FILE *file
= (FILE *) vfile
;
1602 bfd_size_type datasize
= 0;
1603 bfd_size_type dataoff
;
1608 long export_flags
; /* Reserved - should be zero. */
1612 bfd_vma name
; /* RVA - relative to image base. */
1613 long base
; /* Ordinal base. */
1614 unsigned long num_functions
;/* Number in the export address table. */
1615 unsigned long num_names
; /* Number in the name pointer table. */
1616 bfd_vma eat_addr
; /* RVA to the export address table. */
1617 bfd_vma npt_addr
; /* RVA to the Export Name Pointer Table. */
1618 bfd_vma ot_addr
; /* RVA to the Ordinal Table. */
1621 pe_data_type
*pe
= pe_data (abfd
);
1622 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1626 addr
= extra
->DataDirectory
[PE_EXPORT_TABLE
].VirtualAddress
;
1628 if (addr
== 0 && extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
== 0)
1630 /* Maybe the extra header isn't there. Look for the section. */
1631 section
= bfd_get_section_by_name (abfd
, ".edata");
1632 if (section
== NULL
)
1635 addr
= section
->vma
;
1637 datasize
= section
->size
;
1643 addr
+= extra
->ImageBase
;
1645 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1646 if (addr
>= section
->vma
&& addr
< section
->vma
+ section
->size
)
1649 if (section
== NULL
)
1652 _("\nThere is an export table, but the section containing it could not be found\n"));
1655 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1658 _("\nThere is an export table in %s, but that section has no contents\n"),
1663 dataoff
= addr
- section
->vma
;
1664 datasize
= extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
;
1665 if (dataoff
> section
->size
1666 || datasize
> section
->size
- dataoff
)
1669 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1675 /* PR 17512: Handle corrupt PE binaries. */
1679 /* xgettext:c-format */
1680 _("\nThere is an export table in %s, but it is too small (%d)\n"),
1681 section
->name
, (int) datasize
);
1685 /* xgettext:c-format */
1686 fprintf (file
, _("\nThere is an export table in %s at 0x%lx\n"),
1687 section
->name
, (unsigned long) addr
);
1689 data
= (bfd_byte
*) bfd_malloc (datasize
);
1693 if (! bfd_get_section_contents (abfd
, section
, data
,
1694 (file_ptr
) dataoff
, datasize
))
1697 /* Go get Export Directory Table. */
1698 edt
.export_flags
= bfd_get_32 (abfd
, data
+ 0);
1699 edt
.time_stamp
= bfd_get_32 (abfd
, data
+ 4);
1700 edt
.major_ver
= bfd_get_16 (abfd
, data
+ 8);
1701 edt
.minor_ver
= bfd_get_16 (abfd
, data
+ 10);
1702 edt
.name
= bfd_get_32 (abfd
, data
+ 12);
1703 edt
.base
= bfd_get_32 (abfd
, data
+ 16);
1704 edt
.num_functions
= bfd_get_32 (abfd
, data
+ 20);
1705 edt
.num_names
= bfd_get_32 (abfd
, data
+ 24);
1706 edt
.eat_addr
= bfd_get_32 (abfd
, data
+ 28);
1707 edt
.npt_addr
= bfd_get_32 (abfd
, data
+ 32);
1708 edt
.ot_addr
= bfd_get_32 (abfd
, data
+ 36);
1710 adj
= section
->vma
- extra
->ImageBase
+ dataoff
;
1712 /* Dump the EDT first. */
1714 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1718 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt
.export_flags
);
1721 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt
.time_stamp
);
1724 /* xgettext:c-format */
1725 _("Major/Minor \t\t\t%d/%d\n"), edt
.major_ver
, edt
.minor_ver
);
1728 _("Name \t\t\t\t"));
1729 bfd_fprintf_vma (abfd
, file
, edt
.name
);
1731 if ((edt
.name
>= adj
) && (edt
.name
< adj
+ datasize
))
1732 fprintf (file
, " %.*s\n",
1733 (int) (datasize
- (edt
.name
- adj
)),
1734 data
+ edt
.name
- adj
);
1736 fprintf (file
, "(outside .edata section)\n");
1739 _("Ordinal Base \t\t\t%ld\n"), edt
.base
);
1745 _("\tExport Address Table \t\t%08lx\n"),
1749 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt
.num_names
);
1752 _("Table Addresses\n"));
1755 _("\tExport Address Table \t\t"));
1756 bfd_fprintf_vma (abfd
, file
, edt
.eat_addr
);
1757 fprintf (file
, "\n");
1760 _("\tName Pointer Table \t\t"));
1761 bfd_fprintf_vma (abfd
, file
, edt
.npt_addr
);
1762 fprintf (file
, "\n");
1765 _("\tOrdinal Table \t\t\t"));
1766 bfd_fprintf_vma (abfd
, file
, edt
.ot_addr
);
1767 fprintf (file
, "\n");
1769 /* The next table to find is the Export Address Table. It's basically
1770 a list of pointers that either locate a function in this dll, or
1771 forward the call to another dll. Something like:
1776 } export_address_table_entry; */
1779 _("\nExport Address Table -- Ordinal Base %ld\n"),
1782 /* PR 17512: Handle corrupt PE binaries. */
1783 /* PR 17512 file: 140-165018-0.004. */
1784 if (edt
.eat_addr
- adj
>= datasize
1785 /* PR 17512: file: 092b1829 */
1786 || (edt
.num_functions
+ 1) * 4 < edt
.num_functions
1787 || edt
.eat_addr
- adj
+ (edt
.num_functions
+ 1) * 4 > datasize
)
1788 fprintf (file
, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1789 (long) edt
.eat_addr
,
1790 (long) edt
.num_functions
);
1791 else for (i
= 0; i
< edt
.num_functions
; ++i
)
1793 bfd_vma eat_member
= bfd_get_32 (abfd
,
1794 data
+ edt
.eat_addr
+ (i
* 4) - adj
);
1795 if (eat_member
== 0)
1798 if (eat_member
- adj
<= datasize
)
1800 /* This rva is to a name (forwarding function) in our section. */
1801 /* Should locate a function descriptor. */
1803 "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1805 (long) (i
+ edt
.base
),
1806 (unsigned long) eat_member
,
1808 (int)(datasize
- (eat_member
- adj
)),
1809 data
+ eat_member
- adj
);
1813 /* Should locate a function descriptor in the reldata section. */
1815 "\t[%4ld] +base[%4ld] %04lx %s\n",
1817 (long) (i
+ edt
.base
),
1818 (unsigned long) eat_member
,
1823 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1824 /* Dump them in parallel for clarity. */
1826 _("\n[Ordinal/Name Pointer] Table\n"));
1828 /* PR 17512: Handle corrupt PE binaries. */
1829 if (edt
.npt_addr
+ (edt
.num_names
* 4) - adj
>= datasize
1830 /* PR 17512: file: bb68816e. */
1831 || edt
.num_names
* 4 < edt
.num_names
1832 || (data
+ edt
.npt_addr
- adj
) < data
)
1833 /* xgettext:c-format */
1834 fprintf (file
, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1835 (long) edt
.npt_addr
,
1836 (long) edt
.num_names
);
1837 /* PR 17512: file: 140-147171-0.004. */
1838 else if (edt
.ot_addr
+ (edt
.num_names
* 2) - adj
>= datasize
1839 || data
+ edt
.ot_addr
- adj
< data
)
1840 /* xgettext:c-format */
1841 fprintf (file
, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1843 (long) edt
.num_names
);
1844 else for (i
= 0; i
< edt
.num_names
; ++i
)
1849 ord
= bfd_get_16 (abfd
, data
+ edt
.ot_addr
+ (i
* 2) - adj
);
1850 name_ptr
= bfd_get_32 (abfd
, data
+ edt
.npt_addr
+ (i
* 4) - adj
);
1852 if ((name_ptr
- adj
) >= datasize
)
1854 /* xgettext:c-format */
1855 fprintf (file
, _("\t[%4ld] <corrupt offset: %lx>\n"),
1856 (long) ord
, (long) name_ptr
);
1860 char * name
= (char *) data
+ name_ptr
- adj
;
1862 fprintf (file
, "\t[%4ld] %.*s\n", (long) ord
,
1863 (int)((char *)(data
+ datasize
) - name
), name
);
1872 /* This really is architecture dependent. On IA-64, a .pdata entry
1873 consists of three dwords containing relative virtual addresses that
1874 specify the start and end address of the code range the entry
1875 covers and the address of the corresponding unwind info data.
1877 On ARM and SH-4, a compressed PDATA structure is used :
1878 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1879 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1880 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1882 This is the version for uncompressed data. */
1885 pe_print_pdata (bfd
* abfd
, void * vfile
)
1887 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1888 # define PDATA_ROW_SIZE (3 * 8)
1890 # define PDATA_ROW_SIZE (5 * 4)
1892 FILE *file
= (FILE *) vfile
;
1894 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1895 bfd_size_type datasize
= 0;
1897 bfd_size_type start
, stop
;
1898 int onaline
= PDATA_ROW_SIZE
;
1901 || coff_section_data (abfd
, section
) == NULL
1902 || pei_section_data (abfd
, section
) == NULL
)
1905 stop
= pei_section_data (abfd
, section
)->virt_size
;
1906 if ((stop
% onaline
) != 0)
1908 /* xgettext:c-format */
1909 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
1910 (long) stop
, onaline
);
1913 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1914 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1916 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1919 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1920 \t\tAddress Address Handler Data Address Mask\n"));
1923 datasize
= section
->size
;
1927 /* PR 17512: file: 002-193900-0.004. */
1928 if (datasize
< stop
)
1930 /* xgettext:c-format */
1931 fprintf (file
, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"),
1932 (long) stop
, (long) datasize
);
1936 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
1945 for (i
= start
; i
< stop
; i
+= onaline
)
1951 bfd_vma prolog_end_addr
;
1952 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1956 if (i
+ PDATA_ROW_SIZE
> stop
)
1959 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
1960 end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
1961 eh_handler
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 8);
1962 eh_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 12);
1963 prolog_end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 16);
1965 if (begin_addr
== 0 && end_addr
== 0 && eh_handler
== 0
1966 && eh_data
== 0 && prolog_end_addr
== 0)
1967 /* We are probably into the padding of the section now. */
1970 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1971 em_data
= ((eh_handler
& 0x1) << 2) | (prolog_end_addr
& 0x3);
1973 eh_handler
&= ~(bfd_vma
) 0x3;
1974 prolog_end_addr
&= ~(bfd_vma
) 0x3;
1977 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
1978 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
1979 bfd_fprintf_vma (abfd
, file
, end_addr
); fputc (' ', file
);
1980 bfd_fprintf_vma (abfd
, file
, eh_handler
);
1981 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1983 bfd_fprintf_vma (abfd
, file
, eh_data
); fputc (' ', file
);
1984 bfd_fprintf_vma (abfd
, file
, prolog_end_addr
);
1985 fprintf (file
, " %x", em_data
);
1988 #ifdef POWERPC_LE_PE
1989 if (eh_handler
== 0 && eh_data
!= 0)
1991 /* Special bits here, although the meaning may be a little
1992 mysterious. The only one I know for sure is 0x03
1995 0x01 Register Save Millicode
1996 0x02 Register Restore Millicode
1997 0x03 Glue Code Sequence. */
2001 fprintf (file
, _(" Register save millicode"));
2004 fprintf (file
, _(" Register restore millicode"));
2007 fprintf (file
, _(" Glue code sequence"));
2014 fprintf (file
, "\n");
2020 #undef PDATA_ROW_SIZE
2023 typedef struct sym_cache
2030 slurp_symtab (bfd
*abfd
, sym_cache
*psc
)
2032 asymbol
** sy
= NULL
;
2035 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
2041 storage
= bfd_get_symtab_upper_bound (abfd
);
2046 sy
= (asymbol
**) bfd_malloc (storage
);
2051 psc
->symcount
= bfd_canonicalize_symtab (abfd
, sy
);
2052 if (psc
->symcount
< 0)
2058 my_symbol_for_address (bfd
*abfd
, bfd_vma func
, sym_cache
*psc
)
2063 psc
->syms
= slurp_symtab (abfd
, psc
);
2065 for (i
= 0; i
< psc
->symcount
; i
++)
2067 if (psc
->syms
[i
]->section
->vma
+ psc
->syms
[i
]->value
== func
)
2068 return psc
->syms
[i
]->name
;
2075 cleanup_syms (sym_cache
*psc
)
2082 /* This is the version for "compressed" pdata. */
2085 _bfd_XX_print_ce_compressed_pdata (bfd
* abfd
, void * vfile
)
2087 # define PDATA_ROW_SIZE (2 * 4)
2088 FILE *file
= (FILE *) vfile
;
2089 bfd_byte
*data
= NULL
;
2090 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
2091 bfd_size_type datasize
= 0;
2093 bfd_size_type start
, stop
;
2094 int onaline
= PDATA_ROW_SIZE
;
2095 struct sym_cache cache
= {0, 0} ;
2098 || coff_section_data (abfd
, section
) == NULL
2099 || pei_section_data (abfd
, section
) == NULL
)
2102 stop
= pei_section_data (abfd
, section
)->virt_size
;
2103 if ((stop
% onaline
) != 0)
2105 /* xgettext:c-format */
2106 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
2107 (long) stop
, onaline
);
2110 _("\nThe Function Table (interpreted .pdata section contents)\n"));
2113 vma:\t\tBegin Prolog Function Flags Exception EH\n\
2114 \t\tAddress Length Length 32b exc Handler Data\n"));
2116 datasize
= section
->size
;
2120 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2129 for (i
= start
; i
< stop
; i
+= onaline
)
2133 bfd_vma prolog_length
, function_length
;
2134 int flag32bit
, exception_flag
;
2137 if (i
+ PDATA_ROW_SIZE
> stop
)
2140 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
2141 other_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
2143 if (begin_addr
== 0 && other_data
== 0)
2144 /* We are probably into the padding of the section now. */
2147 prolog_length
= (other_data
& 0x000000FF);
2148 function_length
= (other_data
& 0x3FFFFF00) >> 8;
2149 flag32bit
= (int)((other_data
& 0x40000000) >> 30);
2150 exception_flag
= (int)((other_data
& 0x80000000) >> 31);
2153 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
2154 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
2155 bfd_fprintf_vma (abfd
, file
, prolog_length
); fputc (' ', file
);
2156 bfd_fprintf_vma (abfd
, file
, function_length
); fputc (' ', file
);
2157 fprintf (file
, "%2d %2d ", flag32bit
, exception_flag
);
2159 /* Get the exception handler's address and the data passed from the
2160 .text section. This is really the data that belongs with the .pdata
2161 but got "compressed" out for the ARM and SH4 architectures. */
2162 tsection
= bfd_get_section_by_name (abfd
, ".text");
2163 if (tsection
&& coff_section_data (abfd
, tsection
)
2164 && pei_section_data (abfd
, tsection
))
2166 bfd_vma eh_off
= (begin_addr
- 8) - tsection
->vma
;
2169 tdata
= (bfd_byte
*) bfd_malloc (8);
2172 if (bfd_get_section_contents (abfd
, tsection
, tdata
, eh_off
, 8))
2174 bfd_vma eh
, eh_data
;
2176 eh
= bfd_get_32 (abfd
, tdata
);
2177 eh_data
= bfd_get_32 (abfd
, tdata
+ 4);
2178 fprintf (file
, "%08x ", (unsigned int) eh
);
2179 fprintf (file
, "%08x", (unsigned int) eh_data
);
2182 const char *s
= my_symbol_for_address (abfd
, eh
, &cache
);
2185 fprintf (file
, " (%s) ", s
);
2192 fprintf (file
, "\n");
2197 cleanup_syms (& cache
);
2200 #undef PDATA_ROW_SIZE
2204 #define IMAGE_REL_BASED_HIGHADJ 4
2205 static const char * const tbl
[] =
2219 "UNKNOWN", /* MUST be last. */
2223 pe_print_reloc (bfd
* abfd
, void * vfile
)
2225 FILE *file
= (FILE *) vfile
;
2227 asection
*section
= bfd_get_section_by_name (abfd
, ".reloc");
2230 if (section
== NULL
|| section
->size
== 0 || !(section
->flags
& SEC_HAS_CONTENTS
))
2234 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2236 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2244 end
= data
+ section
->size
;
2245 while (p
+ 8 <= end
)
2248 bfd_vma virtual_address
;
2249 unsigned long number
, size
;
2250 bfd_byte
*chunk_end
;
2252 /* The .reloc section is a sequence of blocks, with a header consisting
2253 of two 32 bit quantities, followed by a number of 16 bit entries. */
2254 virtual_address
= bfd_get_32 (abfd
, p
);
2255 size
= bfd_get_32 (abfd
, p
+ 4);
2257 number
= (size
- 8) / 2;
2263 /* xgettext:c-format */
2264 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2265 (unsigned long) virtual_address
, size
, size
, number
);
2267 chunk_end
= p
- 8 + size
;
2268 if (chunk_end
> end
)
2271 while (p
+ 2 <= chunk_end
)
2273 unsigned short e
= bfd_get_16 (abfd
, p
);
2274 unsigned int t
= (e
& 0xF000) >> 12;
2275 int off
= e
& 0x0FFF;
2277 if (t
>= sizeof (tbl
) / sizeof (tbl
[0]))
2278 t
= (sizeof (tbl
) / sizeof (tbl
[0])) - 1;
2281 /* xgettext:c-format */
2282 _("\treloc %4d offset %4x [%4lx] %s"),
2283 j
, off
, (unsigned long) (off
+ virtual_address
), tbl
[t
]);
2288 /* HIGHADJ takes an argument, - the next record *is* the
2289 low 16 bits of addend. */
2290 if (t
== IMAGE_REL_BASED_HIGHADJ
&& p
+ 2 <= chunk_end
)
2292 fprintf (file
, " (%4x)", (unsigned int) bfd_get_16 (abfd
, p
));
2297 fprintf (file
, "\n");
2306 /* A data structure describing the regions of a .rsrc section.
2307 Some fields are filled in as the section is parsed. */
2309 typedef struct rsrc_regions
2311 bfd_byte
* section_start
;
2312 bfd_byte
* section_end
;
2313 bfd_byte
* strings_start
;
2314 bfd_byte
* resource_start
;
2318 rsrc_print_resource_directory (FILE * , bfd
*, unsigned int, bfd_byte
*,
2319 rsrc_regions
*, bfd_vma
);
2321 /* Print the resource entry at DATA, with the text indented by INDENT.
2322 Recusively calls rsrc_print_resource_directory to print the contents
2323 of directory entries.
2324 Returns the address of the end of the data associated with the entry
2325 or section_end + 1 upon failure. */
2328 rsrc_print_resource_entries (FILE * file
,
2330 unsigned int indent
,
2331 bfd_boolean is_name
,
2333 rsrc_regions
* regions
,
2336 unsigned long entry
, addr
, size
;
2339 if (data
+ 8 >= regions
->section_end
)
2340 return regions
->section_end
+ 1;
2342 /* xgettext:c-format */
2343 fprintf (file
, _("%03x %*.s Entry: "), (int)(data
- regions
->section_start
), indent
, " ");
2345 entry
= (unsigned long) bfd_get_32 (abfd
, data
);
2350 /* Note - the documentation says that this field is an RVA value
2351 but windres appears to produce a section relative offset with
2352 the top bit set. Support both styles for now. */
2353 if (HighBitSet (entry
))
2354 name
= regions
->section_start
+ WithoutHighBit (entry
);
2356 name
= regions
->section_start
+ entry
- rva_bias
;
2358 if (name
+ 2 < regions
->section_end
&& name
> regions
->section_start
)
2362 if (regions
->strings_start
== NULL
)
2363 regions
->strings_start
= name
;
2365 len
= bfd_get_16 (abfd
, name
);
2367 fprintf (file
, _("name: [val: %08lx len %d]: "), entry
, len
);
2369 if (name
+ 2 + len
* 2 < regions
->section_end
)
2371 /* This strange loop is to cope with multibyte characters. */
2378 /* Avoid printing control characters. */
2379 if (c
> 0 && c
< 32)
2380 fprintf (file
, "^%c", c
+ 64);
2382 fprintf (file
, "%.1s", name
);
2387 fprintf (file
, _("<corrupt string length: %#x>\n"), len
);
2388 /* PR binutils/17512: Do not try to continue decoding a
2389 corrupted resource section. It is likely to end up with
2390 reams of extraneous output. FIXME: We could probably
2391 continue if we disable the printing of strings... */
2392 return regions
->section_end
+ 1;
2397 fprintf (file
, _("<corrupt string offset: %#lx>\n"), entry
);
2398 return regions
->section_end
+ 1;
2402 fprintf (file
, _("ID: %#08lx"), entry
);
2404 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
2405 fprintf (file
, _(", Value: %#08lx\n"), entry
);
2407 if (HighBitSet (entry
))
2409 data
= regions
->section_start
+ WithoutHighBit (entry
);
2410 if (data
<= regions
->section_start
|| data
> regions
->section_end
)
2411 return regions
->section_end
+ 1;
2413 /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2414 in the resource table. We need some way to detect this. */
2415 return rsrc_print_resource_directory (file
, abfd
, indent
+ 1, data
,
2419 leaf
= regions
->section_start
+ entry
;
2421 if (leaf
+ 16 >= regions
->section_end
2422 /* PR 17512: file: 055dff7e. */
2423 || leaf
< regions
->section_start
)
2424 return regions
->section_end
+ 1;
2426 /* xgettext:c-format */
2427 fprintf (file
, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2428 (int) (entry
), indent
, " ",
2429 addr
= (long) bfd_get_32 (abfd
, leaf
),
2430 size
= (long) bfd_get_32 (abfd
, leaf
+ 4),
2431 (int) bfd_get_32 (abfd
, leaf
+ 8));
2433 /* Check that the reserved entry is 0. */
2434 if (bfd_get_32 (abfd
, leaf
+ 12) != 0
2435 /* And that the data address/size is valid too. */
2436 || (regions
->section_start
+ (addr
- rva_bias
) + size
> regions
->section_end
))
2437 return regions
->section_end
+ 1;
2439 if (regions
->resource_start
== NULL
)
2440 regions
->resource_start
= regions
->section_start
+ (addr
- rva_bias
);
2442 return regions
->section_start
+ (addr
- rva_bias
) + size
;
2445 #define max(a,b) ((a) > (b) ? (a) : (b))
2446 #define min(a,b) ((a) < (b) ? (a) : (b))
2449 rsrc_print_resource_directory (FILE * file
,
2451 unsigned int indent
,
2453 rsrc_regions
* regions
,
2456 unsigned int num_names
, num_ids
;
2457 bfd_byte
* highest_data
= data
;
2459 if (data
+ 16 >= regions
->section_end
)
2460 return regions
->section_end
+ 1;
2462 fprintf (file
, "%03x %*.s ", (int)(data
- regions
->section_start
), indent
, " ");
2465 case 0: fprintf (file
, "Type"); break;
2466 case 2: fprintf (file
, "Name"); break;
2467 case 4: fprintf (file
, "Language"); break;
2469 fprintf (file
, _("<unknown directory type: %d>\n"), indent
);
2470 /* FIXME: For now we end the printing here. If in the
2471 future more directory types are added to the RSRC spec
2472 then we will need to change this. */
2473 return regions
->section_end
+ 1;
2476 /* xgettext:c-format */
2477 fprintf (file
, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2478 (int) bfd_get_32 (abfd
, data
),
2479 (long) bfd_get_32 (abfd
, data
+ 4),
2480 (int) bfd_get_16 (abfd
, data
+ 8),
2481 (int) bfd_get_16 (abfd
, data
+ 10),
2482 num_names
= (int) bfd_get_16 (abfd
, data
+ 12),
2483 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14));
2486 while (num_names
--)
2488 bfd_byte
* entry_end
;
2490 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, TRUE
,
2491 data
, regions
, rva_bias
);
2493 highest_data
= max (highest_data
, entry_end
);
2494 if (entry_end
>= regions
->section_end
)
2500 bfd_byte
* entry_end
;
2502 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, FALSE
,
2503 data
, regions
, rva_bias
);
2505 highest_data
= max (highest_data
, entry_end
);
2506 if (entry_end
>= regions
->section_end
)
2510 return max (highest_data
, data
);
2513 /* Display the contents of a .rsrc section. We do not try to
2514 reproduce the resources, windres does that. Instead we dump
2515 the tables in a human readable format. */
2518 rsrc_print_section (bfd
* abfd
, void * vfile
)
2522 FILE * file
= (FILE *) vfile
;
2523 bfd_size_type datasize
;
2526 rsrc_regions regions
;
2528 pe
= pe_data (abfd
);
2532 section
= bfd_get_section_by_name (abfd
, ".rsrc");
2533 if (section
== NULL
)
2535 if (!(section
->flags
& SEC_HAS_CONTENTS
))
2538 datasize
= section
->size
;
2542 rva_bias
= section
->vma
- pe
->pe_opthdr
.ImageBase
;
2544 if (! bfd_malloc_and_get_section (abfd
, section
, & data
))
2551 regions
.section_start
= data
;
2552 regions
.section_end
= data
+ datasize
;
2553 regions
.strings_start
= NULL
;
2554 regions
.resource_start
= NULL
;
2557 fprintf (file
, "\nThe .rsrc Resource Directory section:\n");
2559 while (data
< regions
.section_end
)
2561 bfd_byte
* p
= data
;
2563 data
= rsrc_print_resource_directory (file
, abfd
, 0, data
, & regions
, rva_bias
);
2565 if (data
== regions
.section_end
+ 1)
2566 fprintf (file
, _("Corrupt .rsrc section detected!\n"));
2569 /* Align data before continuing. */
2570 int align
= (1 << section
->alignment_power
) - 1;
2572 data
= (bfd_byte
*) (((ptrdiff_t) (data
+ align
)) & ~ align
);
2573 rva_bias
+= data
- p
;
2575 /* For reasons that are unclear .rsrc sections are sometimes created
2576 aligned to a 1^3 boundary even when their alignment is set at
2577 1^2. Catch that case here before we issue a spurious warning
2579 if (data
== (regions
.section_end
- 4))
2580 data
= regions
.section_end
;
2581 else if (data
< regions
.section_end
)
2583 /* If the extra data is all zeros then do not complain.
2584 This is just padding so that the section meets the
2585 page size requirements. */
2586 while (++ data
< regions
.section_end
)
2589 if (data
< regions
.section_end
)
2590 fprintf (file
, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2595 if (regions
.strings_start
!= NULL
)
2596 fprintf (file
, _(" String table starts at offset: %#03x\n"),
2597 (int) (regions
.strings_start
- regions
.section_start
));
2598 if (regions
.resource_start
!= NULL
)
2599 fprintf (file
, _(" Resources start at offset: %#03x\n"),
2600 (int) (regions
.resource_start
- regions
.section_start
));
2602 free (regions
.section_start
);
2606 #define IMAGE_NUMBEROF_DEBUG_TYPES 17
2608 static char * debug_type_names
[IMAGE_NUMBEROF_DEBUG_TYPES
] =
2630 pe_print_debugdata (bfd
* abfd
, void * vfile
)
2632 FILE *file
= (FILE *) vfile
;
2633 pe_data_type
*pe
= pe_data (abfd
);
2634 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2637 bfd_size_type dataoff
;
2640 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2641 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2646 addr
+= extra
->ImageBase
;
2647 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2649 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2653 if (section
== NULL
)
2656 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2659 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
2662 _("\nThere is a debug directory in %s, but that section has no contents\n"),
2666 else if (section
->size
< size
)
2669 _("\nError: section %s contains the debug data starting address but it is too small\n"),
2674 fprintf (file
, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2675 section
->name
, (unsigned long) addr
);
2677 dataoff
= addr
- section
->vma
;
2679 if (size
> (section
->size
- dataoff
))
2681 fprintf (file
, _("The debug data size field in the data directory is too big for the section"));
2686 _("Type Size Rva Offset\n"));
2688 /* Read the whole section. */
2689 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2696 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2698 const char *type_name
;
2699 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2700 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2701 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2703 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2705 if ((idd
.Type
) >= IMAGE_NUMBEROF_DEBUG_TYPES
)
2706 type_name
= debug_type_names
[0];
2708 type_name
= debug_type_names
[idd
.Type
];
2710 fprintf (file
, " %2ld %14s %08lx %08lx %08lx\n",
2711 idd
.Type
, type_name
, idd
.SizeOfData
,
2712 idd
.AddressOfRawData
, idd
.PointerToRawData
);
2714 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_CODEVIEW
)
2716 char signature
[CV_INFO_SIGNATURE_LENGTH
* 2 + 1];
2717 /* PR 17512: file: 065-29434-0.001:0.1
2718 We need to use a 32-bit aligned buffer
2719 to safely read in a codeview record. */
2720 char buffer
[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO
);
2722 CODEVIEW_INFO
*cvinfo
= (CODEVIEW_INFO
*) buffer
;
2724 /* The debug entry doesn't have to have to be in a section,
2725 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2726 if (!_bfd_XXi_slurp_codeview_record (abfd
, (file_ptr
) idd
.PointerToRawData
,
2727 idd
.SizeOfData
, cvinfo
))
2730 for (j
= 0; j
< cvinfo
->SignatureLength
; j
++)
2731 sprintf (&signature
[j
*2], "%02x", cvinfo
->Signature
[j
] & 0xff);
2733 /* xgettext:c-format */
2734 fprintf (file
, _("(format %c%c%c%c signature %s age %ld)\n"),
2735 buffer
[0], buffer
[1], buffer
[2], buffer
[3],
2736 signature
, cvinfo
->Age
);
2742 if (size
% sizeof (struct external_IMAGE_DEBUG_DIRECTORY
) != 0)
2744 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2749 /* Print out the program headers. */
2752 _bfd_XX_print_private_bfd_data_common (bfd
* abfd
, void * vfile
)
2754 FILE *file
= (FILE *) vfile
;
2756 pe_data_type
*pe
= pe_data (abfd
);
2757 struct internal_extra_pe_aouthdr
*i
= &pe
->pe_opthdr
;
2758 const char *subsystem_name
= NULL
;
2761 /* The MS dumpbin program reportedly ands with 0xff0f before
2762 printing the characteristics field. Not sure why. No reason to
2764 fprintf (file
, _("\nCharacteristics 0x%x\n"), pe
->real_flags
);
2766 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2767 PF (IMAGE_FILE_RELOCS_STRIPPED
, "relocations stripped");
2768 PF (IMAGE_FILE_EXECUTABLE_IMAGE
, "executable");
2769 PF (IMAGE_FILE_LINE_NUMS_STRIPPED
, "line numbers stripped");
2770 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED
, "symbols stripped");
2771 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE
, "large address aware");
2772 PF (IMAGE_FILE_BYTES_REVERSED_LO
, "little endian");
2773 PF (IMAGE_FILE_32BIT_MACHINE
, "32 bit words");
2774 PF (IMAGE_FILE_DEBUG_STRIPPED
, "debugging information removed");
2775 PF (IMAGE_FILE_SYSTEM
, "system file");
2776 PF (IMAGE_FILE_DLL
, "DLL");
2777 PF (IMAGE_FILE_BYTES_REVERSED_HI
, "big endian");
2780 /* ctime implies '\n'. */
2782 time_t t
= pe
->coff
.timestamp
;
2783 fprintf (file
, "\nTime/Date\t\t%s", ctime (&t
));
2786 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2787 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2789 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2790 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2792 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2793 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2798 case IMAGE_NT_OPTIONAL_HDR_MAGIC
:
2801 case IMAGE_NT_OPTIONAL_HDR64_MAGIC
:
2804 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC
:
2811 fprintf (file
, "Magic\t\t\t%04x", i
->Magic
);
2813 fprintf (file
, "\t(%s)",name
);
2814 fprintf (file
, "\nMajorLinkerVersion\t%d\n", i
->MajorLinkerVersion
);
2815 fprintf (file
, "MinorLinkerVersion\t%d\n", i
->MinorLinkerVersion
);
2816 fprintf (file
, "SizeOfCode\t\t");
2817 bfd_fprintf_vma (abfd
, file
, i
->SizeOfCode
);
2818 fprintf (file
, "\nSizeOfInitializedData\t");
2819 bfd_fprintf_vma (abfd
, file
, i
->SizeOfInitializedData
);
2820 fprintf (file
, "\nSizeOfUninitializedData\t");
2821 bfd_fprintf_vma (abfd
, file
, i
->SizeOfUninitializedData
);
2822 fprintf (file
, "\nAddressOfEntryPoint\t");
2823 bfd_fprintf_vma (abfd
, file
, i
->AddressOfEntryPoint
);
2824 fprintf (file
, "\nBaseOfCode\t\t");
2825 bfd_fprintf_vma (abfd
, file
, i
->BaseOfCode
);
2826 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2827 /* PE32+ does not have BaseOfData member! */
2828 fprintf (file
, "\nBaseOfData\t\t");
2829 bfd_fprintf_vma (abfd
, file
, i
->BaseOfData
);
2832 fprintf (file
, "\nImageBase\t\t");
2833 bfd_fprintf_vma (abfd
, file
, i
->ImageBase
);
2834 fprintf (file
, "\nSectionAlignment\t%08x\n", i
->SectionAlignment
);
2835 fprintf (file
, "FileAlignment\t\t%08x\n", i
->FileAlignment
);
2836 fprintf (file
, "MajorOSystemVersion\t%d\n", i
->MajorOperatingSystemVersion
);
2837 fprintf (file
, "MinorOSystemVersion\t%d\n", i
->MinorOperatingSystemVersion
);
2838 fprintf (file
, "MajorImageVersion\t%d\n", i
->MajorImageVersion
);
2839 fprintf (file
, "MinorImageVersion\t%d\n", i
->MinorImageVersion
);
2840 fprintf (file
, "MajorSubsystemVersion\t%d\n", i
->MajorSubsystemVersion
);
2841 fprintf (file
, "MinorSubsystemVersion\t%d\n", i
->MinorSubsystemVersion
);
2842 fprintf (file
, "Win32Version\t\t%08x\n", i
->Reserved1
);
2843 fprintf (file
, "SizeOfImage\t\t%08x\n", i
->SizeOfImage
);
2844 fprintf (file
, "SizeOfHeaders\t\t%08x\n", i
->SizeOfHeaders
);
2845 fprintf (file
, "CheckSum\t\t%08x\n", i
->CheckSum
);
2847 switch (i
->Subsystem
)
2849 case IMAGE_SUBSYSTEM_UNKNOWN
:
2850 subsystem_name
= "unspecified";
2852 case IMAGE_SUBSYSTEM_NATIVE
:
2853 subsystem_name
= "NT native";
2855 case IMAGE_SUBSYSTEM_WINDOWS_GUI
:
2856 subsystem_name
= "Windows GUI";
2858 case IMAGE_SUBSYSTEM_WINDOWS_CUI
:
2859 subsystem_name
= "Windows CUI";
2861 case IMAGE_SUBSYSTEM_POSIX_CUI
:
2862 subsystem_name
= "POSIX CUI";
2864 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI
:
2865 subsystem_name
= "Wince CUI";
2867 // These are from UEFI Platform Initialization Specification 1.1.
2868 case IMAGE_SUBSYSTEM_EFI_APPLICATION
:
2869 subsystem_name
= "EFI application";
2871 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
:
2872 subsystem_name
= "EFI boot service driver";
2874 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
:
2875 subsystem_name
= "EFI runtime driver";
2877 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER
:
2878 subsystem_name
= "SAL runtime driver";
2880 // This is from revision 8.0 of the MS PE/COFF spec
2881 case IMAGE_SUBSYSTEM_XBOX
:
2882 subsystem_name
= "XBOX";
2884 // Added default case for clarity - subsystem_name is NULL anyway.
2886 subsystem_name
= NULL
;
2889 fprintf (file
, "Subsystem\t\t%08x", i
->Subsystem
);
2891 fprintf (file
, "\t(%s)", subsystem_name
);
2892 fprintf (file
, "\nDllCharacteristics\t%08x\n", i
->DllCharacteristics
);
2893 fprintf (file
, "SizeOfStackReserve\t");
2894 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackReserve
);
2895 fprintf (file
, "\nSizeOfStackCommit\t");
2896 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackCommit
);
2897 fprintf (file
, "\nSizeOfHeapReserve\t");
2898 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapReserve
);
2899 fprintf (file
, "\nSizeOfHeapCommit\t");
2900 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapCommit
);
2901 fprintf (file
, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i
->LoaderFlags
);
2902 fprintf (file
, "NumberOfRvaAndSizes\t%08lx\n",
2903 (unsigned long) i
->NumberOfRvaAndSizes
);
2905 fprintf (file
, "\nThe Data Directory\n");
2906 for (j
= 0; j
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; j
++)
2908 fprintf (file
, "Entry %1x ", j
);
2909 bfd_fprintf_vma (abfd
, file
, i
->DataDirectory
[j
].VirtualAddress
);
2910 fprintf (file
, " %08lx ", (unsigned long) i
->DataDirectory
[j
].Size
);
2911 fprintf (file
, "%s\n", dir_names
[j
]);
2914 pe_print_idata (abfd
, vfile
);
2915 pe_print_edata (abfd
, vfile
);
2916 if (bfd_coff_have_print_pdata (abfd
))
2917 bfd_coff_print_pdata (abfd
, vfile
);
2919 pe_print_pdata (abfd
, vfile
);
2920 pe_print_reloc (abfd
, vfile
);
2921 pe_print_debugdata (abfd
, file
);
2923 rsrc_print_section (abfd
, vfile
);
2929 is_vma_in_section (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sect
, void *obj
)
2931 bfd_vma addr
= * (bfd_vma
*) obj
;
2932 return (addr
>= sect
->vma
) && (addr
< (sect
->vma
+ sect
->size
));
2936 find_section_by_vma (bfd
*abfd
, bfd_vma addr
)
2938 return bfd_sections_find_if (abfd
, is_vma_in_section
, (void *) & addr
);
2941 /* Copy any private info we understand from the input bfd
2942 to the output bfd. */
2945 _bfd_XX_bfd_copy_private_bfd_data_common (bfd
* ibfd
, bfd
* obfd
)
2947 pe_data_type
*ipe
, *ope
;
2949 /* One day we may try to grok other private data. */
2950 if (ibfd
->xvec
->flavour
!= bfd_target_coff_flavour
2951 || obfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
2954 ipe
= pe_data (ibfd
);
2955 ope
= pe_data (obfd
);
2957 /* pe_opthdr is copied in copy_object. */
2958 ope
->dll
= ipe
->dll
;
2960 /* Don't copy input subsystem if output is different from input. */
2961 if (obfd
->xvec
!= ibfd
->xvec
)
2962 ope
->pe_opthdr
.Subsystem
= IMAGE_SUBSYSTEM_UNKNOWN
;
2964 /* For strip: if we removed .reloc, we'll make a real mess of things
2965 if we don't remove this entry as well. */
2966 if (! pe_data (obfd
)->has_reloc_section
)
2968 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].VirtualAddress
= 0;
2969 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].Size
= 0;
2972 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2973 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2975 if (! pe_data (ibfd
)->has_reloc_section
2976 && ! (pe_data (ibfd
)->real_flags
& IMAGE_FILE_RELOCS_STRIPPED
))
2977 pe_data (obfd
)->dont_strip_reloc
= 1;
2979 memcpy (ope
->dos_message
, ipe
->dos_message
, sizeof (ope
->dos_message
));
2981 /* The file offsets contained in the debug directory need rewriting. */
2982 if (ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
!= 0)
2984 bfd_vma addr
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
2985 + ope
->pe_opthdr
.ImageBase
;
2986 asection
*section
= find_section_by_vma (obfd
, addr
);
2989 if (section
&& bfd_malloc_and_get_section (obfd
, section
, &data
))
2992 struct external_IMAGE_DEBUG_DIRECTORY
*dd
=
2993 (struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ (addr
- section
->vma
));
2995 /* PR 17512: file: 0f15796a. */
2996 if ((unsigned long) ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
2997 > section
->size
- (addr
- section
->vma
))
2999 /* xgettext:c-format */
3001 (_("%pB: Data Directory size (%lx) "
3002 "exceeds space left in section (%" PRIx64
")"),
3003 obfd
, ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
,
3004 (uint64_t) (section
->size
- (addr
- section
->vma
)));
3009 for (i
= 0; i
< ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
3010 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
3012 asection
*ddsection
;
3013 struct external_IMAGE_DEBUG_DIRECTORY
*edd
= &(dd
[i
]);
3014 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
3016 _bfd_XXi_swap_debugdir_in (obfd
, edd
, &idd
);
3018 if (idd
.AddressOfRawData
== 0)
3019 continue; /* RVA 0 means only offset is valid, not handled yet. */
3021 ddsection
= find_section_by_vma (obfd
, idd
.AddressOfRawData
+ ope
->pe_opthdr
.ImageBase
);
3023 continue; /* Not in a section! */
3025 idd
.PointerToRawData
= ddsection
->filepos
+ (idd
.AddressOfRawData
3026 + ope
->pe_opthdr
.ImageBase
) - ddsection
->vma
;
3028 _bfd_XXi_swap_debugdir_out (obfd
, &idd
, edd
);
3031 if (!bfd_set_section_contents (obfd
, section
, data
, 0, section
->size
))
3033 _bfd_error_handler (_("failed to update file offsets in debug directory"));
3041 _bfd_error_handler (_("%pB: failed to read debug data section"), obfd
);
3049 /* Copy private section data. */
3052 _bfd_XX_bfd_copy_private_section_data (bfd
*ibfd
,
3057 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
3058 || bfd_get_flavour (obfd
) != bfd_target_coff_flavour
)
3061 if (coff_section_data (ibfd
, isec
) != NULL
3062 && pei_section_data (ibfd
, isec
) != NULL
)
3064 if (coff_section_data (obfd
, osec
) == NULL
)
3066 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
3067 osec
->used_by_bfd
= bfd_zalloc (obfd
, amt
);
3068 if (osec
->used_by_bfd
== NULL
)
3072 if (pei_section_data (obfd
, osec
) == NULL
)
3074 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
3075 coff_section_data (obfd
, osec
)->tdata
= bfd_zalloc (obfd
, amt
);
3076 if (coff_section_data (obfd
, osec
)->tdata
== NULL
)
3080 pei_section_data (obfd
, osec
)->virt_size
=
3081 pei_section_data (ibfd
, isec
)->virt_size
;
3082 pei_section_data (obfd
, osec
)->pe_flags
=
3083 pei_section_data (ibfd
, isec
)->pe_flags
;
3090 _bfd_XX_get_symbol_info (bfd
* abfd
, asymbol
*symbol
, symbol_info
*ret
)
3092 coff_get_symbol_info (abfd
, symbol
, ret
);
3095 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
3097 sort_x64_pdata (const void *l
, const void *r
)
3099 const char *lp
= (const char *) l
;
3100 const char *rp
= (const char *) r
;
3102 vl
= bfd_getl32 (lp
); vr
= bfd_getl32 (rp
);
3104 return (vl
< vr
? -1 : 1);
3105 /* We compare just begin address. */
3110 /* Functions to process a .rsrc section. */
3112 static unsigned int sizeof_leaves
;
3113 static unsigned int sizeof_strings
;
3114 static unsigned int sizeof_tables_and_entries
;
3117 rsrc_count_directory (bfd
*, bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
3120 rsrc_count_entries (bfd
* abfd
,
3121 bfd_boolean is_name
,
3122 bfd_byte
* datastart
,
3127 unsigned long entry
, addr
, size
;
3129 if (data
+ 8 >= dataend
)
3136 entry
= (long) bfd_get_32 (abfd
, data
);
3138 if (HighBitSet (entry
))
3139 name
= datastart
+ WithoutHighBit (entry
);
3141 name
= datastart
+ entry
- rva_bias
;
3143 if (name
+ 2 >= dataend
|| name
< datastart
)
3146 unsigned int len
= bfd_get_16 (abfd
, name
);
3147 if (len
== 0 || len
> 256)
3151 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
3153 if (HighBitSet (entry
))
3155 data
= datastart
+ WithoutHighBit (entry
);
3157 if (data
<= datastart
|| data
>= dataend
)
3160 return rsrc_count_directory (abfd
, datastart
, data
, dataend
, rva_bias
);
3163 if (datastart
+ entry
+ 16 >= dataend
)
3166 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
);
3167 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4);
3169 return datastart
+ addr
- rva_bias
+ size
;
3173 rsrc_count_directory (bfd
* abfd
,
3174 bfd_byte
* datastart
,
3179 unsigned int num_entries
, num_ids
;
3180 bfd_byte
* highest_data
= data
;
3182 if (data
+ 16 >= dataend
)
3185 num_entries
= (int) bfd_get_16 (abfd
, data
+ 12);
3186 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14);
3188 num_entries
+= num_ids
;
3192 while (num_entries
--)
3194 bfd_byte
* entry_end
;
3196 entry_end
= rsrc_count_entries (abfd
, num_entries
>= num_ids
,
3197 datastart
, data
, dataend
, rva_bias
);
3199 highest_data
= max (highest_data
, entry_end
);
3200 if (entry_end
>= dataend
)
3204 return max (highest_data
, data
);
3207 typedef struct rsrc_dir_chain
3209 unsigned int num_entries
;
3210 struct rsrc_entry
* first_entry
;
3211 struct rsrc_entry
* last_entry
;
3214 typedef struct rsrc_directory
3216 unsigned int characteristics
;
3221 rsrc_dir_chain names
;
3224 struct rsrc_entry
* entry
;
3227 typedef struct rsrc_string
3233 typedef struct rsrc_leaf
3236 unsigned int codepage
;
3240 typedef struct rsrc_entry
3242 bfd_boolean is_name
;
3246 struct rsrc_string name
;
3252 struct rsrc_directory
* directory
;
3253 struct rsrc_leaf
* leaf
;
3256 struct rsrc_entry
* next_entry
;
3257 struct rsrc_directory
* parent
;
3261 rsrc_parse_directory (bfd
*, rsrc_directory
*, bfd_byte
*,
3262 bfd_byte
*, bfd_byte
*, bfd_vma
, rsrc_entry
*);
3265 rsrc_parse_entry (bfd
* abfd
,
3266 bfd_boolean is_name
,
3268 bfd_byte
* datastart
,
3272 rsrc_directory
* parent
)
3274 unsigned long val
, addr
, size
;
3276 val
= bfd_get_32 (abfd
, data
);
3278 entry
->parent
= parent
;
3279 entry
->is_name
= is_name
;
3285 if (HighBitSet (val
))
3287 val
= WithoutHighBit (val
);
3289 address
= datastart
+ val
;
3293 address
= datastart
+ val
- rva_bias
;
3296 if (address
+ 3 > dataend
)
3299 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, address
);
3300 entry
->name_id
.name
.string
= address
+ 2;
3303 entry
->name_id
.id
= val
;
3305 val
= bfd_get_32 (abfd
, data
+ 4);
3307 if (HighBitSet (val
))
3309 entry
->is_dir
= TRUE
;
3310 entry
->value
.directory
= bfd_malloc (sizeof * entry
->value
.directory
);
3311 if (entry
->value
.directory
== NULL
)
3314 return rsrc_parse_directory (abfd
, entry
->value
.directory
,
3316 datastart
+ WithoutHighBit (val
),
3317 dataend
, rva_bias
, entry
);
3320 entry
->is_dir
= FALSE
;
3321 entry
->value
.leaf
= bfd_malloc (sizeof * entry
->value
.leaf
);
3322 if (entry
->value
.leaf
== NULL
)
3325 data
= datastart
+ val
;
3326 if (data
< datastart
|| data
>= dataend
)
3329 addr
= bfd_get_32 (abfd
, data
);
3330 size
= entry
->value
.leaf
->size
= bfd_get_32 (abfd
, data
+ 4);
3331 entry
->value
.leaf
->codepage
= bfd_get_32 (abfd
, data
+ 8);
3332 /* FIXME: We assume that the reserved field (data + 12) is OK. */
3334 entry
->value
.leaf
->data
= bfd_malloc (size
);
3335 if (entry
->value
.leaf
->data
== NULL
)
3338 memcpy (entry
->value
.leaf
->data
, datastart
+ addr
- rva_bias
, size
);
3339 return datastart
+ (addr
- rva_bias
) + size
;
3343 rsrc_parse_entries (bfd
* abfd
,
3344 rsrc_dir_chain
* chain
,
3345 bfd_boolean is_name
,
3346 bfd_byte
* highest_data
,
3347 bfd_byte
* datastart
,
3351 rsrc_directory
* parent
)
3356 if (chain
->num_entries
== 0)
3358 chain
->first_entry
= chain
->last_entry
= NULL
;
3359 return highest_data
;
3362 entry
= bfd_malloc (sizeof * entry
);
3366 chain
->first_entry
= entry
;
3368 for (i
= chain
->num_entries
; i
--;)
3370 bfd_byte
* entry_end
;
3372 entry_end
= rsrc_parse_entry (abfd
, is_name
, entry
, datastart
,
3373 data
, dataend
, rva_bias
, parent
);
3375 highest_data
= max (entry_end
, highest_data
);
3376 if (entry_end
> dataend
)
3381 entry
->next_entry
= bfd_malloc (sizeof * entry
);
3382 entry
= entry
->next_entry
;
3387 entry
->next_entry
= NULL
;
3390 chain
->last_entry
= entry
;
3392 return highest_data
;
3396 rsrc_parse_directory (bfd
* abfd
,
3397 rsrc_directory
* table
,
3398 bfd_byte
* datastart
,
3404 bfd_byte
* highest_data
= data
;
3409 table
->characteristics
= bfd_get_32 (abfd
, data
);
3410 table
->time
= bfd_get_32 (abfd
, data
+ 4);
3411 table
->major
= bfd_get_16 (abfd
, data
+ 8);
3412 table
->minor
= bfd_get_16 (abfd
, data
+ 10);
3413 table
->names
.num_entries
= bfd_get_16 (abfd
, data
+ 12);
3414 table
->ids
.num_entries
= bfd_get_16 (abfd
, data
+ 14);
3415 table
->entry
= entry
;
3419 highest_data
= rsrc_parse_entries (abfd
, & table
->names
, TRUE
, data
,
3420 datastart
, data
, dataend
, rva_bias
, table
);
3421 data
+= table
->names
.num_entries
* 8;
3423 highest_data
= rsrc_parse_entries (abfd
, & table
->ids
, FALSE
, highest_data
,
3424 datastart
, data
, dataend
, rva_bias
, table
);
3425 data
+= table
->ids
.num_entries
* 8;
3427 return max (highest_data
, data
);
3430 typedef struct rsrc_write_data
3433 bfd_byte
* datastart
;
3434 bfd_byte
* next_table
;
3435 bfd_byte
* next_leaf
;
3436 bfd_byte
* next_string
;
3437 bfd_byte
* next_data
;
3442 rsrc_write_string (rsrc_write_data
* data
,
3443 rsrc_string
* string
)
3445 bfd_put_16 (data
->abfd
, string
->len
, data
->next_string
);
3446 memcpy (data
->next_string
+ 2, string
->string
, string
->len
* 2);
3447 data
->next_string
+= (string
->len
+ 1) * 2;
3450 static inline unsigned int
3451 rsrc_compute_rva (rsrc_write_data
* data
,
3454 return (addr
- data
->datastart
) + data
->rva_bias
;
3458 rsrc_write_leaf (rsrc_write_data
* data
,
3461 bfd_put_32 (data
->abfd
, rsrc_compute_rva (data
, data
->next_data
),
3463 bfd_put_32 (data
->abfd
, leaf
->size
, data
->next_leaf
+ 4);
3464 bfd_put_32 (data
->abfd
, leaf
->codepage
, data
->next_leaf
+ 8);
3465 bfd_put_32 (data
->abfd
, 0 /*reserved*/, data
->next_leaf
+ 12);
3466 data
->next_leaf
+= 16;
3468 memcpy (data
->next_data
, leaf
->data
, leaf
->size
);
3469 /* An undocumented feature of Windows resources is that each unit
3470 of raw data is 8-byte aligned... */
3471 data
->next_data
+= ((leaf
->size
+ 7) & ~7);
3474 static void rsrc_write_directory (rsrc_write_data
*, rsrc_directory
*);
3477 rsrc_write_entry (rsrc_write_data
* data
,
3483 bfd_put_32 (data
->abfd
,
3484 SetHighBit (data
->next_string
- data
->datastart
),
3486 rsrc_write_string (data
, & entry
->name_id
.name
);
3489 bfd_put_32 (data
->abfd
, entry
->name_id
.id
, where
);
3493 bfd_put_32 (data
->abfd
,
3494 SetHighBit (data
->next_table
- data
->datastart
),
3496 rsrc_write_directory (data
, entry
->value
.directory
);
3500 bfd_put_32 (data
->abfd
, data
->next_leaf
- data
->datastart
, where
+ 4);
3501 rsrc_write_leaf (data
, entry
->value
.leaf
);
3506 rsrc_compute_region_sizes (rsrc_directory
* dir
)
3508 struct rsrc_entry
* entry
;
3513 sizeof_tables_and_entries
+= 16;
3515 for (entry
= dir
->names
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3517 sizeof_tables_and_entries
+= 8;
3519 sizeof_strings
+= (entry
->name_id
.name
.len
+ 1) * 2;
3522 rsrc_compute_region_sizes (entry
->value
.directory
);
3524 sizeof_leaves
+= 16;
3527 for (entry
= dir
->ids
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3529 sizeof_tables_and_entries
+= 8;
3532 rsrc_compute_region_sizes (entry
->value
.directory
);
3534 sizeof_leaves
+= 16;
3539 rsrc_write_directory (rsrc_write_data
* data
,
3540 rsrc_directory
* dir
)
3544 bfd_byte
* next_entry
;
3547 bfd_put_32 (data
->abfd
, dir
->characteristics
, data
->next_table
);
3548 bfd_put_32 (data
->abfd
, 0 /*dir->time*/, data
->next_table
+ 4);
3549 bfd_put_16 (data
->abfd
, dir
->major
, data
->next_table
+ 8);
3550 bfd_put_16 (data
->abfd
, dir
->minor
, data
->next_table
+ 10);
3551 bfd_put_16 (data
->abfd
, dir
->names
.num_entries
, data
->next_table
+ 12);
3552 bfd_put_16 (data
->abfd
, dir
->ids
.num_entries
, data
->next_table
+ 14);
3554 /* Compute where the entries and the next table will be placed. */
3555 next_entry
= data
->next_table
+ 16;
3556 data
->next_table
= next_entry
+ (dir
->names
.num_entries
* 8)
3557 + (dir
->ids
.num_entries
* 8);
3558 nt
= data
->next_table
;
3560 /* Write the entries. */
3561 for (i
= dir
->names
.num_entries
, entry
= dir
->names
.first_entry
;
3562 i
> 0 && entry
!= NULL
;
3563 i
--, entry
= entry
->next_entry
)
3565 BFD_ASSERT (entry
->is_name
);
3566 rsrc_write_entry (data
, next_entry
, entry
);
3569 BFD_ASSERT (i
== 0);
3570 BFD_ASSERT (entry
== NULL
);
3572 for (i
= dir
->ids
.num_entries
, entry
= dir
->ids
.first_entry
;
3573 i
> 0 && entry
!= NULL
;
3574 i
--, entry
= entry
->next_entry
)
3576 BFD_ASSERT (! entry
->is_name
);
3577 rsrc_write_entry (data
, next_entry
, entry
);
3580 BFD_ASSERT (i
== 0);
3581 BFD_ASSERT (entry
== NULL
);
3582 BFD_ASSERT (nt
== next_entry
);
3585 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3586 /* Return the length (number of units) of the first character in S,
3587 putting its 'ucs4_t' representation in *PUC. */
3590 #if defined HAVE_WCTYPE_H
3591 u16_mbtouc (wint_t * puc
, const unsigned short * s
, unsigned int n
)
3593 u16_mbtouc (wchar_t * puc
, const unsigned short * s
, unsigned int n
)
3596 unsigned short c
= * s
;
3598 if (c
< 0xd800 || c
>= 0xe000)
3608 if (s
[1] >= 0xdc00 && s
[1] < 0xe000)
3610 *puc
= 0x10000 + ((c
- 0xd800) << 10) + (s
[1] - 0xdc00);
3616 /* Incomplete multibyte character. */
3622 /* Invalid multibyte character. */
3626 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3628 /* Perform a comparison of two entries. */
3630 rsrc_cmp (bfd_boolean is_name
, rsrc_entry
* a
, rsrc_entry
* b
)
3639 return a
->name_id
.id
- b
->name_id
.id
;
3641 /* We have to perform a case insenstive, unicode string comparison... */
3642 astring
= a
->name_id
.name
.string
;
3643 alen
= a
->name_id
.name
.len
;
3644 bstring
= b
->name_id
.name
.string
;
3645 blen
= b
->name_id
.name
.len
;
3647 #if defined __CYGWIN__ || defined __MINGW32__
3648 /* Under Windows hosts (both Cygwin and Mingw types),
3649 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3650 function however goes by different names in the two environments... */
3654 #define rscpcmp wcsncasecmp
3657 #define rscpcmp wcsnicmp
3660 res
= rscpcmp ((const wchar_t *) astring
, (const wchar_t *) bstring
,
3663 #elif defined HAVE_WCHAR_H
3668 for (i
= min (alen
, blen
); i
--; astring
+= 2, bstring
+= 2)
3670 #if defined HAVE_WCTYPE_H
3678 /* Convert UTF-16 unicode characters into wchar_t characters
3679 so that we can then perform a case insensitive comparison. */
3680 unsigned int Alen
= u16_mbtouc (& awc
, (const unsigned short *) astring
, 2);
3681 unsigned int Blen
= u16_mbtouc (& bwc
, (const unsigned short *) bstring
, 2);
3686 #ifdef HAVE_WCTYPE_H
3687 awc
= towlower (awc
);
3688 bwc
= towlower (bwc
);
3692 res
= wcsncasecmp (& awc
, & bwc
, 1);
3699 /* Do the best we can - a case sensitive, untranslated comparison. */
3700 res
= memcmp (astring
, bstring
, min (alen
, blen
) * 2);
3710 rsrc_print_name (char * buffer
, rsrc_string string
)
3713 bfd_byte
* name
= string
.string
;
3715 for (i
= string
.len
; i
--; name
+= 2)
3716 sprintf (buffer
+ strlen (buffer
), "%.1s", name
);
3720 rsrc_resource_name (rsrc_entry
* entry
, rsrc_directory
* dir
)
3722 static char buffer
[256];
3723 bfd_boolean is_string
= FALSE
;
3727 if (dir
!= NULL
&& dir
->entry
!= NULL
&& dir
->entry
->parent
!= NULL
3728 && dir
->entry
->parent
->entry
!= NULL
)
3730 strcpy (buffer
, "type: ");
3731 if (dir
->entry
->parent
->entry
->is_name
)
3732 rsrc_print_name (buffer
+ strlen (buffer
),
3733 dir
->entry
->parent
->entry
->name_id
.name
);
3736 unsigned int id
= dir
->entry
->parent
->entry
->name_id
.id
;
3738 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3741 case 1: strcat (buffer
, " (CURSOR)"); break;
3742 case 2: strcat (buffer
, " (BITMAP)"); break;
3743 case 3: strcat (buffer
, " (ICON)"); break;
3744 case 4: strcat (buffer
, " (MENU)"); break;
3745 case 5: strcat (buffer
, " (DIALOG)"); break;
3746 case 6: strcat (buffer
, " (STRING)"); is_string
= TRUE
; break;
3747 case 7: strcat (buffer
, " (FONTDIR)"); break;
3748 case 8: strcat (buffer
, " (FONT)"); break;
3749 case 9: strcat (buffer
, " (ACCELERATOR)"); break;
3750 case 10: strcat (buffer
, " (RCDATA)"); break;
3751 case 11: strcat (buffer
, " (MESSAGETABLE)"); break;
3752 case 12: strcat (buffer
, " (GROUP_CURSOR)"); break;
3753 case 14: strcat (buffer
, " (GROUP_ICON)"); break;
3754 case 16: strcat (buffer
, " (VERSION)"); break;
3755 case 17: strcat (buffer
, " (DLGINCLUDE)"); break;
3756 case 19: strcat (buffer
, " (PLUGPLAY)"); break;
3757 case 20: strcat (buffer
, " (VXD)"); break;
3758 case 21: strcat (buffer
, " (ANICURSOR)"); break;
3759 case 22: strcat (buffer
, " (ANIICON)"); break;
3760 case 23: strcat (buffer
, " (HTML)"); break;
3761 case 24: strcat (buffer
, " (MANIFEST)"); break;
3762 case 240: strcat (buffer
, " (DLGINIT)"); break;
3763 case 241: strcat (buffer
, " (TOOLBAR)"); break;
3768 if (dir
!= NULL
&& dir
->entry
!= NULL
)
3770 strcat (buffer
, " name: ");
3771 if (dir
->entry
->is_name
)
3772 rsrc_print_name (buffer
+ strlen (buffer
), dir
->entry
->name_id
.name
);
3775 unsigned int id
= dir
->entry
->name_id
.id
;
3777 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3780 sprintf (buffer
+ strlen (buffer
), " (resource id range: %d - %d)",
3781 (id
- 1) << 4, (id
<< 4) - 1);
3787 strcat (buffer
, " lang: ");
3790 rsrc_print_name (buffer
+ strlen (buffer
), entry
->name_id
.name
);
3792 sprintf (buffer
+ strlen (buffer
), "%x", entry
->name_id
.id
);
3798 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3799 their ID is stored in the NAME entry. The bottom four bits are used as
3800 an index into unicode string table that makes up the data of the leaf.
3801 So identical type-name-lang string resources may not actually be
3804 This function is called when we have detected two string resources with
3805 match top-28-bit IDs. We have to scan the string tables inside the leaves
3806 and discover if there are any real collisions. If there are then we report
3807 them and return FALSE. Otherwise we copy any strings from B into A and
3808 then return TRUE. */
3811 rsrc_merge_string_entries (rsrc_entry
* a ATTRIBUTE_UNUSED
,
3812 rsrc_entry
* b ATTRIBUTE_UNUSED
)
3814 unsigned int copy_needed
= 0;
3818 bfd_byte
* new_data
;
3821 /* Step one: Find out what we have to do. */
3822 BFD_ASSERT (! a
->is_dir
);
3823 astring
= a
->value
.leaf
->data
;
3825 BFD_ASSERT (! b
->is_dir
);
3826 bstring
= b
->value
.leaf
->data
;
3828 for (i
= 0; i
< 16; i
++)
3830 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3831 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3835 copy_needed
+= blen
* 2;
3839 else if (alen
!= blen
)
3840 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3842 /* alen == blen != 0. We might have two identical strings. If so we
3843 can ignore the second one. There is no need for wchar_t vs UTF-16
3844 theatrics here - we are only interested in (case sensitive) equality. */
3845 else if (memcmp (astring
+ 2, bstring
+ 2, alen
* 2) != 0)
3848 astring
+= (alen
+ 1) * 2;
3849 bstring
+= (blen
+ 1) * 2;
3854 if (a
->parent
!= NULL
3855 && a
->parent
->entry
!= NULL
3856 && !a
->parent
->entry
->is_name
)
3857 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3858 ((a
->parent
->entry
->name_id
.id
- 1) << 4) + i
);
3862 if (copy_needed
== 0)
3865 /* If we reach here then A and B must both have non-colliding strings.
3866 (We never get string resources with fully empty string tables).
3867 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3869 new_data
= bfd_malloc (a
->value
.leaf
->size
+ copy_needed
);
3870 if (new_data
== NULL
)
3874 astring
= a
->value
.leaf
->data
;
3875 bstring
= b
->value
.leaf
->data
;
3877 for (i
= 0; i
< 16; i
++)
3879 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3880 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3884 memcpy (nstring
, astring
, (alen
+ 1) * 2);
3885 nstring
+= (alen
+ 1) * 2;
3889 memcpy (nstring
, bstring
, (blen
+ 1) * 2);
3890 nstring
+= (blen
+ 1) * 2;
3898 astring
+= (alen
+ 1) * 2;
3899 bstring
+= (blen
+ 1) * 2;
3902 BFD_ASSERT (nstring
- new_data
== (signed) (a
->value
.leaf
->size
+ copy_needed
));
3904 free (a
->value
.leaf
->data
);
3905 a
->value
.leaf
->data
= new_data
;
3906 a
->value
.leaf
->size
+= copy_needed
;
3911 static void rsrc_merge (rsrc_entry
*, rsrc_entry
*);
3913 /* Sort the entries in given part of the directory.
3914 We use an old fashioned bubble sort because we are dealing
3915 with lists and we want to handle matches specially. */
3918 rsrc_sort_entries (rsrc_dir_chain
* chain
,
3919 bfd_boolean is_name
,
3920 rsrc_directory
* dir
)
3924 rsrc_entry
** points_to_entry
;
3925 bfd_boolean swapped
;
3927 if (chain
->num_entries
< 2)
3933 points_to_entry
= & chain
->first_entry
;
3934 entry
= * points_to_entry
;
3935 next
= entry
->next_entry
;
3939 signed int cmp
= rsrc_cmp (is_name
, entry
, next
);
3943 entry
->next_entry
= next
->next_entry
;
3944 next
->next_entry
= entry
;
3945 * points_to_entry
= next
;
3946 points_to_entry
= & next
->next_entry
;
3947 next
= entry
->next_entry
;
3952 if (entry
->is_dir
&& next
->is_dir
)
3954 /* When we encounter identical directory entries we have to
3955 merge them together. The exception to this rule is for
3956 resource manifests - there can only be one of these,
3957 even if they differ in language. Zero-language manifests
3958 are assumed to be default manifests (provided by the
3959 Cygwin/MinGW build system) and these can be silently dropped,
3960 unless that would reduce the number of manifests to zero.
3961 There should only ever be one non-zero lang manifest -
3962 if there are more it is an error. A non-zero lang
3963 manifest takes precedence over a default manifest. */
3965 && entry
->name_id
.id
== 1
3967 && dir
->entry
!= NULL
3968 && !dir
->entry
->is_name
3969 && dir
->entry
->name_id
.id
== 0x18)
3971 if (next
->value
.directory
->names
.num_entries
== 0
3972 && next
->value
.directory
->ids
.num_entries
== 1
3973 && !next
->value
.directory
->ids
.first_entry
->is_name
3974 && next
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3975 /* Fall through so that NEXT is dropped. */
3977 else if (entry
->value
.directory
->names
.num_entries
== 0
3978 && entry
->value
.directory
->ids
.num_entries
== 1
3979 && !entry
->value
.directory
->ids
.first_entry
->is_name
3980 && entry
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3982 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
3983 entry
->next_entry
= next
->next_entry
;
3984 next
->next_entry
= entry
;
3985 * points_to_entry
= next
;
3986 points_to_entry
= & next
->next_entry
;
3987 next
= entry
->next_entry
;
3992 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3993 bfd_set_error (bfd_error_file_truncated
);
3997 /* Unhook NEXT from the chain. */
3998 /* FIXME: memory loss here. */
3999 entry
->next_entry
= next
->next_entry
;
4000 chain
->num_entries
--;
4001 if (chain
->num_entries
< 2)
4003 next
= next
->next_entry
;
4006 rsrc_merge (entry
, next
);
4008 else if (entry
->is_dir
!= next
->is_dir
)
4010 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
4011 bfd_set_error (bfd_error_file_truncated
);
4016 /* Otherwise with identical leaves we issue an error
4017 message - because there should never be duplicates.
4018 The exception is Type 18/Name 1/Lang 0 which is the
4019 defaul manifest - this can just be dropped. */
4021 && entry
->name_id
.id
== 0
4023 && dir
->entry
!= NULL
4024 && !dir
->entry
->is_name
4025 && dir
->entry
->name_id
.id
== 1
4026 && dir
->entry
->parent
!= NULL
4027 && dir
->entry
->parent
->entry
!= NULL
4028 && !dir
->entry
->parent
->entry
->is_name
4029 && dir
->entry
->parent
->entry
->name_id
.id
== 0x18 /* RT_MANIFEST */)
4031 else if (dir
!= NULL
4032 && dir
->entry
!= NULL
4033 && dir
->entry
->parent
!= NULL
4034 && dir
->entry
->parent
->entry
!= NULL
4035 && !dir
->entry
->parent
->entry
->is_name
4036 && dir
->entry
->parent
->entry
->name_id
.id
== 0x6 /* RT_STRING */)
4038 /* Strings need special handling. */
4039 if (! rsrc_merge_string_entries (entry
, next
))
4041 /* _bfd_error_handler should have been called inside merge_strings. */
4042 bfd_set_error (bfd_error_file_truncated
);
4049 || dir
->entry
== NULL
4050 || dir
->entry
->parent
== NULL
4051 || dir
->entry
->parent
->entry
== NULL
)
4052 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
4054 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
4055 rsrc_resource_name (entry
, dir
));
4056 bfd_set_error (bfd_error_file_truncated
);
4061 /* Unhook NEXT from the chain. */
4062 entry
->next_entry
= next
->next_entry
;
4063 chain
->num_entries
--;
4064 if (chain
->num_entries
< 2)
4066 next
= next
->next_entry
;
4070 points_to_entry
= & entry
->next_entry
;
4072 next
= next
->next_entry
;
4077 chain
->last_entry
= entry
;
4082 /* Attach B's chain onto A. */
4084 rsrc_attach_chain (rsrc_dir_chain
* achain
, rsrc_dir_chain
* bchain
)
4086 if (bchain
->num_entries
== 0)
4089 achain
->num_entries
+= bchain
->num_entries
;
4091 if (achain
->first_entry
== NULL
)
4093 achain
->first_entry
= bchain
->first_entry
;
4094 achain
->last_entry
= bchain
->last_entry
;
4098 achain
->last_entry
->next_entry
= bchain
->first_entry
;
4099 achain
->last_entry
= bchain
->last_entry
;
4102 bchain
->num_entries
= 0;
4103 bchain
->first_entry
= bchain
->last_entry
= NULL
;
4107 rsrc_merge (struct rsrc_entry
* a
, struct rsrc_entry
* b
)
4109 rsrc_directory
* adir
;
4110 rsrc_directory
* bdir
;
4112 BFD_ASSERT (a
->is_dir
);
4113 BFD_ASSERT (b
->is_dir
);
4115 adir
= a
->value
.directory
;
4116 bdir
= b
->value
.directory
;
4118 if (adir
->characteristics
!= bdir
->characteristics
)
4120 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics"));
4121 bfd_set_error (bfd_error_file_truncated
);
4125 if (adir
->major
!= bdir
->major
|| adir
->minor
!= bdir
->minor
)
4127 _bfd_error_handler (_(".rsrc merge failure: differing directory versions"));
4128 bfd_set_error (bfd_error_file_truncated
);
4132 /* Attach B's name chain to A. */
4133 rsrc_attach_chain (& adir
->names
, & bdir
->names
);
4135 /* Attach B's ID chain to A. */
4136 rsrc_attach_chain (& adir
->ids
, & bdir
->ids
);
4138 /* Now sort A's entries. */
4139 rsrc_sort_entries (& adir
->names
, TRUE
, adir
);
4140 rsrc_sort_entries (& adir
->ids
, FALSE
, adir
);
4143 /* Check the .rsrc section. If it contains multiple concatenated
4144 resources then we must merge them properly. Otherwise Windows
4145 will ignore all but the first set. */
4148 rsrc_process_section (bfd
* abfd
,
4149 struct coff_final_link_info
* pfinfo
)
4151 rsrc_directory new_table
;
4157 bfd_byte
* datastart
;
4159 bfd_byte
* new_data
;
4160 unsigned int num_resource_sets
;
4161 rsrc_directory
* type_tables
;
4162 rsrc_write_data write_data
;
4165 unsigned int num_input_rsrc
= 0;
4166 unsigned int max_num_input_rsrc
= 4;
4167 ptrdiff_t * rsrc_sizes
= NULL
;
4169 new_table
.names
.num_entries
= 0;
4170 new_table
.ids
.num_entries
= 0;
4172 sec
= bfd_get_section_by_name (abfd
, ".rsrc");
4173 if (sec
== NULL
|| (size
= sec
->rawsize
) == 0)
4176 pe
= pe_data (abfd
);
4180 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4182 data
= bfd_malloc (size
);
4188 if (! bfd_get_section_contents (abfd
, sec
, data
, 0, size
))
4191 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4192 their lengths. Note - we rely upon the fact that the linker script
4193 does *not* sort the input .rsrc sections, so that the order in the
4194 linkinfo list matches the order in the output .rsrc section.
4196 We need to know the lengths because each input .rsrc section has padding
4197 at the end of a variable amount. (It does not appear to be based upon
4198 the section alignment or the file alignment). We need to skip any
4199 padding bytes when parsing the input .rsrc sections. */
4200 rsrc_sizes
= bfd_malloc (max_num_input_rsrc
* sizeof * rsrc_sizes
);
4201 if (rsrc_sizes
== NULL
)
4204 for (input
= pfinfo
->info
->input_bfds
;
4206 input
= input
->link
.next
)
4208 asection
* rsrc_sec
= bfd_get_section_by_name (input
, ".rsrc");
4210 /* PR 18372 - skip discarded .rsrc sections. */
4211 if (rsrc_sec
!= NULL
&& !discarded_section (rsrc_sec
))
4213 if (num_input_rsrc
== max_num_input_rsrc
)
4215 max_num_input_rsrc
+= 10;
4216 rsrc_sizes
= bfd_realloc (rsrc_sizes
, max_num_input_rsrc
4217 * sizeof * rsrc_sizes
);
4218 if (rsrc_sizes
== NULL
)
4222 BFD_ASSERT (rsrc_sec
->size
> 0);
4223 rsrc_sizes
[num_input_rsrc
++] = rsrc_sec
->size
;
4227 if (num_input_rsrc
< 2)
4230 /* Step one: Walk the section, computing the size of the tables,
4231 leaves and data and decide if we need to do anything. */
4232 dataend
= data
+ size
;
4233 num_resource_sets
= 0;
4235 while (data
< dataend
)
4237 bfd_byte
* p
= data
;
4239 data
= rsrc_count_directory (abfd
, data
, data
, dataend
, rva_bias
);
4243 /* Corrupted .rsrc section - cannot merge. */
4244 _bfd_error_handler (_("%pB: .rsrc merge failure: corrupt .rsrc section"),
4246 bfd_set_error (bfd_error_file_truncated
);
4250 if ((data
- p
) > rsrc_sizes
[num_resource_sets
])
4252 _bfd_error_handler (_("%pB: .rsrc merge failure: unexpected .rsrc size"),
4254 bfd_set_error (bfd_error_file_truncated
);
4257 /* FIXME: Should we add a check for "data - p" being much smaller
4258 than rsrc_sizes[num_resource_sets] ? */
4260 data
= p
+ rsrc_sizes
[num_resource_sets
];
4261 rva_bias
+= data
- p
;
4262 ++ num_resource_sets
;
4264 BFD_ASSERT (num_resource_sets
== num_input_rsrc
);
4266 /* Step two: Walk the data again, building trees of the resources. */
4268 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4270 type_tables
= bfd_malloc (num_resource_sets
* sizeof * type_tables
);
4271 if (type_tables
== NULL
)
4275 while (data
< dataend
)
4277 bfd_byte
* p
= data
;
4279 (void) rsrc_parse_directory (abfd
, type_tables
+ indx
, data
, data
,
4280 dataend
, rva_bias
, NULL
);
4281 data
= p
+ rsrc_sizes
[indx
];
4282 rva_bias
+= data
- p
;
4285 BFD_ASSERT (indx
== num_resource_sets
);
4287 /* Step three: Merge the top level tables (there can be only one).
4289 We must ensure that the merged entries are in ascending order.
4291 We also thread the top level table entries from the old tree onto
4292 the new table, so that they can be pulled off later. */
4294 /* FIXME: Should we verify that all type tables are the same ? */
4295 new_table
.characteristics
= type_tables
[0].characteristics
;
4296 new_table
.time
= type_tables
[0].time
;
4297 new_table
.major
= type_tables
[0].major
;
4298 new_table
.minor
= type_tables
[0].minor
;
4300 /* Chain the NAME entries onto the table. */
4301 new_table
.names
.first_entry
= NULL
;
4302 new_table
.names
.last_entry
= NULL
;
4304 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4305 rsrc_attach_chain (& new_table
.names
, & type_tables
[indx
].names
);
4307 rsrc_sort_entries (& new_table
.names
, TRUE
, & new_table
);
4309 /* Chain the ID entries onto the table. */
4310 new_table
.ids
.first_entry
= NULL
;
4311 new_table
.ids
.last_entry
= NULL
;
4313 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4314 rsrc_attach_chain (& new_table
.ids
, & type_tables
[indx
].ids
);
4316 rsrc_sort_entries (& new_table
.ids
, FALSE
, & new_table
);
4318 /* Step four: Create new contents for the .rsrc section. */
4319 /* Step four point one: Compute the size of each region of the .rsrc section.
4320 We do this now, rather than earlier, as the merging above may have dropped
4322 sizeof_leaves
= sizeof_strings
= sizeof_tables_and_entries
= 0;
4323 rsrc_compute_region_sizes (& new_table
);
4324 /* We increment sizeof_strings to make sure that resource data
4325 starts on an 8-byte boundary. FIXME: Is this correct ? */
4326 sizeof_strings
= (sizeof_strings
+ 7) & ~ 7;
4328 new_data
= bfd_zalloc (abfd
, size
);
4329 if (new_data
== NULL
)
4332 write_data
.abfd
= abfd
;
4333 write_data
.datastart
= new_data
;
4334 write_data
.next_table
= new_data
;
4335 write_data
.next_leaf
= new_data
+ sizeof_tables_and_entries
;
4336 write_data
.next_string
= write_data
.next_leaf
+ sizeof_leaves
;
4337 write_data
.next_data
= write_data
.next_string
+ sizeof_strings
;
4338 write_data
.rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4340 rsrc_write_directory (& write_data
, & new_table
);
4342 /* Step five: Replace the old contents with the new.
4343 We don't recompute the size as it's too late here to shrink section.
4344 See PR ld/20193 for more details. */
4345 bfd_set_section_contents (pfinfo
->output_bfd
, sec
, new_data
, 0, size
);
4346 sec
->size
= sec
->rawsize
= size
;
4349 /* Step six: Free all the memory that we have used. */
4350 /* FIXME: Free the resource tree, if we have one. */
4355 /* Handle the .idata section and other things that need symbol table
4359 _bfd_XXi_final_link_postscript (bfd
* abfd
, struct coff_final_link_info
*pfinfo
)
4361 struct coff_link_hash_entry
*h1
;
4362 struct bfd_link_info
*info
= pfinfo
->info
;
4363 bfd_boolean result
= TRUE
;
4365 /* There are a few fields that need to be filled in now while we
4366 have symbol table access.
4368 The .idata subsections aren't directly available as sections, but
4369 they are in the symbol table, so get them from there. */
4371 /* The import directory. This is the address of .idata$2, with size
4372 of .idata$2 + .idata$3. */
4373 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4374 ".idata$2", FALSE
, FALSE
, TRUE
);
4377 /* PR ld/2729: We cannot rely upon all the output sections having been
4378 created properly, so check before referencing them. Issue a warning
4379 message for any sections tht could not be found. */
4380 if ((h1
->root
.type
== bfd_link_hash_defined
4381 || h1
->root
.type
== bfd_link_hash_defweak
)
4382 && h1
->root
.u
.def
.section
!= NULL
4383 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4384 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
=
4385 (h1
->root
.u
.def
.value
4386 + h1
->root
.u
.def
.section
->output_section
->vma
4387 + h1
->root
.u
.def
.section
->output_offset
);
4391 (_("%pB: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4396 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4397 ".idata$4", FALSE
, FALSE
, TRUE
);
4399 && (h1
->root
.type
== bfd_link_hash_defined
4400 || h1
->root
.type
== bfd_link_hash_defweak
)
4401 && h1
->root
.u
.def
.section
!= NULL
4402 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4403 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].Size
=
4404 ((h1
->root
.u
.def
.value
4405 + h1
->root
.u
.def
.section
->output_section
->vma
4406 + h1
->root
.u
.def
.section
->output_offset
)
4407 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
);
4411 (_("%pB: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4416 /* The import address table. This is the size/address of
4418 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4419 ".idata$5", FALSE
, FALSE
, TRUE
);
4421 && (h1
->root
.type
== bfd_link_hash_defined
4422 || h1
->root
.type
== bfd_link_hash_defweak
)
4423 && h1
->root
.u
.def
.section
!= NULL
4424 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4425 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4426 (h1
->root
.u
.def
.value
4427 + h1
->root
.u
.def
.section
->output_section
->vma
4428 + h1
->root
.u
.def
.section
->output_offset
);
4432 (_("%pB: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4437 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4438 ".idata$6", FALSE
, FALSE
, TRUE
);
4440 && (h1
->root
.type
== bfd_link_hash_defined
4441 || h1
->root
.type
== bfd_link_hash_defweak
)
4442 && h1
->root
.u
.def
.section
!= NULL
4443 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4444 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4445 ((h1
->root
.u
.def
.value
4446 + h1
->root
.u
.def
.section
->output_section
->vma
4447 + h1
->root
.u
.def
.section
->output_offset
)
4448 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
);
4452 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4459 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4460 "__IAT_start__", FALSE
, FALSE
, TRUE
);
4462 && (h1
->root
.type
== bfd_link_hash_defined
4463 || h1
->root
.type
== bfd_link_hash_defweak
)
4464 && h1
->root
.u
.def
.section
!= NULL
4465 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4470 (h1
->root
.u
.def
.value
4471 + h1
->root
.u
.def
.section
->output_section
->vma
4472 + h1
->root
.u
.def
.section
->output_offset
);
4474 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4475 "__IAT_end__", FALSE
, FALSE
, TRUE
);
4477 && (h1
->root
.type
== bfd_link_hash_defined
4478 || h1
->root
.type
== bfd_link_hash_defweak
)
4479 && h1
->root
.u
.def
.section
!= NULL
4480 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4482 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4483 ((h1
->root
.u
.def
.value
4484 + h1
->root
.u
.def
.section
->output_section
->vma
4485 + h1
->root
.u
.def
.section
->output_offset
)
4487 if (pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
!= 0)
4488 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4489 iat_va
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
4494 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4495 " because .idata$6 is missing"), abfd
);
4501 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4502 (bfd_get_symbol_leading_char (abfd
) != 0
4503 ? "__tls_used" : "_tls_used"),
4504 FALSE
, FALSE
, TRUE
);
4507 if ((h1
->root
.type
== bfd_link_hash_defined
4508 || h1
->root
.type
== bfd_link_hash_defweak
)
4509 && h1
->root
.u
.def
.section
!= NULL
4510 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4511 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].VirtualAddress
=
4512 (h1
->root
.u
.def
.value
4513 + h1
->root
.u
.def
.section
->output_section
->vma
4514 + h1
->root
.u
.def
.section
->output_offset
4515 - pe_data (abfd
)->pe_opthdr
.ImageBase
);
4519 (_("%pB: unable to fill in DataDictionary[9] because __tls_used is missing"),
4523 /* According to PECOFF sepcifications by Microsoft version 8.2
4524 the TLS data directory consists of 4 pointers, followed
4525 by two 4-byte integer. This implies that the total size
4526 is different for 32-bit and 64-bit executables. */
4527 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4528 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x18;
4530 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x28;
4534 /* If there is a .pdata section and we have linked pdata finally, we
4535 need to sort the entries ascending. */
4536 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4538 asection
*sec
= bfd_get_section_by_name (abfd
, ".pdata");
4542 bfd_size_type x
= sec
->rawsize
;
4543 bfd_byte
*tmp_data
= NULL
;
4546 tmp_data
= bfd_malloc (x
);
4548 if (tmp_data
!= NULL
)
4550 if (bfd_get_section_contents (abfd
, sec
, tmp_data
, 0, x
))
4554 12, sort_x64_pdata
);
4555 bfd_set_section_contents (pfinfo
->output_bfd
, sec
,
4566 rsrc_process_section (abfd
, pfinfo
);
4568 /* If we couldn't find idata$2, we either have an excessively
4569 trivial program or are in DEEP trouble; we have to assume trivial