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 12
2608 static char * debug_type_names
[IMAGE_NUMBEROF_DEBUG_TYPES
] =
2625 pe_print_debugdata (bfd
* abfd
, void * vfile
)
2627 FILE *file
= (FILE *) vfile
;
2628 pe_data_type
*pe
= pe_data (abfd
);
2629 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2632 bfd_size_type dataoff
;
2635 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2636 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2641 addr
+= extra
->ImageBase
;
2642 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2644 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2648 if (section
== NULL
)
2651 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2654 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
2657 _("\nThere is a debug directory in %s, but that section has no contents\n"),
2661 else if (section
->size
< size
)
2664 _("\nError: section %s contains the debug data starting address but it is too small\n"),
2669 fprintf (file
, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2670 section
->name
, (unsigned long) addr
);
2672 dataoff
= addr
- section
->vma
;
2674 if (size
> (section
->size
- dataoff
))
2676 fprintf (file
, _("The debug data size field in the data directory is too big for the section"));
2681 _("Type Size Rva Offset\n"));
2683 /* Read the whole section. */
2684 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2691 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2693 const char *type_name
;
2694 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2695 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2696 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2698 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2700 if ((idd
.Type
) >= IMAGE_NUMBEROF_DEBUG_TYPES
)
2701 type_name
= debug_type_names
[0];
2703 type_name
= debug_type_names
[idd
.Type
];
2705 fprintf (file
, " %2ld %14s %08lx %08lx %08lx\n",
2706 idd
.Type
, type_name
, idd
.SizeOfData
,
2707 idd
.AddressOfRawData
, idd
.PointerToRawData
);
2709 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_CODEVIEW
)
2711 char signature
[CV_INFO_SIGNATURE_LENGTH
* 2 + 1];
2712 /* PR 17512: file: 065-29434-0.001:0.1
2713 We need to use a 32-bit aligned buffer
2714 to safely read in a codeview record. */
2715 char buffer
[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO
);
2717 CODEVIEW_INFO
*cvinfo
= (CODEVIEW_INFO
*) buffer
;
2719 /* The debug entry doesn't have to have to be in a section,
2720 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2721 if (!_bfd_XXi_slurp_codeview_record (abfd
, (file_ptr
) idd
.PointerToRawData
,
2722 idd
.SizeOfData
, cvinfo
))
2725 for (j
= 0; j
< cvinfo
->SignatureLength
; j
++)
2726 sprintf (&signature
[j
*2], "%02x", cvinfo
->Signature
[j
] & 0xff);
2728 /* xgettext:c-format */
2729 fprintf (file
, _("(format %c%c%c%c signature %s age %ld)\n"),
2730 buffer
[0], buffer
[1], buffer
[2], buffer
[3],
2731 signature
, cvinfo
->Age
);
2737 if (size
% sizeof (struct external_IMAGE_DEBUG_DIRECTORY
) != 0)
2739 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2744 /* Print out the program headers. */
2747 _bfd_XX_print_private_bfd_data_common (bfd
* abfd
, void * vfile
)
2749 FILE *file
= (FILE *) vfile
;
2751 pe_data_type
*pe
= pe_data (abfd
);
2752 struct internal_extra_pe_aouthdr
*i
= &pe
->pe_opthdr
;
2753 const char *subsystem_name
= NULL
;
2756 /* The MS dumpbin program reportedly ands with 0xff0f before
2757 printing the characteristics field. Not sure why. No reason to
2759 fprintf (file
, _("\nCharacteristics 0x%x\n"), pe
->real_flags
);
2761 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2762 PF (IMAGE_FILE_RELOCS_STRIPPED
, "relocations stripped");
2763 PF (IMAGE_FILE_EXECUTABLE_IMAGE
, "executable");
2764 PF (IMAGE_FILE_LINE_NUMS_STRIPPED
, "line numbers stripped");
2765 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED
, "symbols stripped");
2766 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE
, "large address aware");
2767 PF (IMAGE_FILE_BYTES_REVERSED_LO
, "little endian");
2768 PF (IMAGE_FILE_32BIT_MACHINE
, "32 bit words");
2769 PF (IMAGE_FILE_DEBUG_STRIPPED
, "debugging information removed");
2770 PF (IMAGE_FILE_SYSTEM
, "system file");
2771 PF (IMAGE_FILE_DLL
, "DLL");
2772 PF (IMAGE_FILE_BYTES_REVERSED_HI
, "big endian");
2775 /* ctime implies '\n'. */
2777 time_t t
= pe
->coff
.timestamp
;
2778 fprintf (file
, "\nTime/Date\t\t%s", ctime (&t
));
2781 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2782 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2784 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2785 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2787 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2788 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2793 case IMAGE_NT_OPTIONAL_HDR_MAGIC
:
2796 case IMAGE_NT_OPTIONAL_HDR64_MAGIC
:
2799 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC
:
2806 fprintf (file
, "Magic\t\t\t%04x", i
->Magic
);
2808 fprintf (file
, "\t(%s)",name
);
2809 fprintf (file
, "\nMajorLinkerVersion\t%d\n", i
->MajorLinkerVersion
);
2810 fprintf (file
, "MinorLinkerVersion\t%d\n", i
->MinorLinkerVersion
);
2811 fprintf (file
, "SizeOfCode\t\t");
2812 bfd_fprintf_vma (abfd
, file
, i
->SizeOfCode
);
2813 fprintf (file
, "\nSizeOfInitializedData\t");
2814 bfd_fprintf_vma (abfd
, file
, i
->SizeOfInitializedData
);
2815 fprintf (file
, "\nSizeOfUninitializedData\t");
2816 bfd_fprintf_vma (abfd
, file
, i
->SizeOfUninitializedData
);
2817 fprintf (file
, "\nAddressOfEntryPoint\t");
2818 bfd_fprintf_vma (abfd
, file
, i
->AddressOfEntryPoint
);
2819 fprintf (file
, "\nBaseOfCode\t\t");
2820 bfd_fprintf_vma (abfd
, file
, i
->BaseOfCode
);
2821 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2822 /* PE32+ does not have BaseOfData member! */
2823 fprintf (file
, "\nBaseOfData\t\t");
2824 bfd_fprintf_vma (abfd
, file
, i
->BaseOfData
);
2827 fprintf (file
, "\nImageBase\t\t");
2828 bfd_fprintf_vma (abfd
, file
, i
->ImageBase
);
2829 fprintf (file
, "\nSectionAlignment\t%08x\n", i
->SectionAlignment
);
2830 fprintf (file
, "FileAlignment\t\t%08x\n", i
->FileAlignment
);
2831 fprintf (file
, "MajorOSystemVersion\t%d\n", i
->MajorOperatingSystemVersion
);
2832 fprintf (file
, "MinorOSystemVersion\t%d\n", i
->MinorOperatingSystemVersion
);
2833 fprintf (file
, "MajorImageVersion\t%d\n", i
->MajorImageVersion
);
2834 fprintf (file
, "MinorImageVersion\t%d\n", i
->MinorImageVersion
);
2835 fprintf (file
, "MajorSubsystemVersion\t%d\n", i
->MajorSubsystemVersion
);
2836 fprintf (file
, "MinorSubsystemVersion\t%d\n", i
->MinorSubsystemVersion
);
2837 fprintf (file
, "Win32Version\t\t%08x\n", i
->Reserved1
);
2838 fprintf (file
, "SizeOfImage\t\t%08x\n", i
->SizeOfImage
);
2839 fprintf (file
, "SizeOfHeaders\t\t%08x\n", i
->SizeOfHeaders
);
2840 fprintf (file
, "CheckSum\t\t%08x\n", i
->CheckSum
);
2842 switch (i
->Subsystem
)
2844 case IMAGE_SUBSYSTEM_UNKNOWN
:
2845 subsystem_name
= "unspecified";
2847 case IMAGE_SUBSYSTEM_NATIVE
:
2848 subsystem_name
= "NT native";
2850 case IMAGE_SUBSYSTEM_WINDOWS_GUI
:
2851 subsystem_name
= "Windows GUI";
2853 case IMAGE_SUBSYSTEM_WINDOWS_CUI
:
2854 subsystem_name
= "Windows CUI";
2856 case IMAGE_SUBSYSTEM_POSIX_CUI
:
2857 subsystem_name
= "POSIX CUI";
2859 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI
:
2860 subsystem_name
= "Wince CUI";
2862 // These are from UEFI Platform Initialization Specification 1.1.
2863 case IMAGE_SUBSYSTEM_EFI_APPLICATION
:
2864 subsystem_name
= "EFI application";
2866 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
:
2867 subsystem_name
= "EFI boot service driver";
2869 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
:
2870 subsystem_name
= "EFI runtime driver";
2872 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER
:
2873 subsystem_name
= "SAL runtime driver";
2875 // This is from revision 8.0 of the MS PE/COFF spec
2876 case IMAGE_SUBSYSTEM_XBOX
:
2877 subsystem_name
= "XBOX";
2879 // Added default case for clarity - subsystem_name is NULL anyway.
2881 subsystem_name
= NULL
;
2884 fprintf (file
, "Subsystem\t\t%08x", i
->Subsystem
);
2886 fprintf (file
, "\t(%s)", subsystem_name
);
2887 fprintf (file
, "\nDllCharacteristics\t%08x\n", i
->DllCharacteristics
);
2888 fprintf (file
, "SizeOfStackReserve\t");
2889 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackReserve
);
2890 fprintf (file
, "\nSizeOfStackCommit\t");
2891 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackCommit
);
2892 fprintf (file
, "\nSizeOfHeapReserve\t");
2893 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapReserve
);
2894 fprintf (file
, "\nSizeOfHeapCommit\t");
2895 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapCommit
);
2896 fprintf (file
, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i
->LoaderFlags
);
2897 fprintf (file
, "NumberOfRvaAndSizes\t%08lx\n",
2898 (unsigned long) i
->NumberOfRvaAndSizes
);
2900 fprintf (file
, "\nThe Data Directory\n");
2901 for (j
= 0; j
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; j
++)
2903 fprintf (file
, "Entry %1x ", j
);
2904 bfd_fprintf_vma (abfd
, file
, i
->DataDirectory
[j
].VirtualAddress
);
2905 fprintf (file
, " %08lx ", (unsigned long) i
->DataDirectory
[j
].Size
);
2906 fprintf (file
, "%s\n", dir_names
[j
]);
2909 pe_print_idata (abfd
, vfile
);
2910 pe_print_edata (abfd
, vfile
);
2911 if (bfd_coff_have_print_pdata (abfd
))
2912 bfd_coff_print_pdata (abfd
, vfile
);
2914 pe_print_pdata (abfd
, vfile
);
2915 pe_print_reloc (abfd
, vfile
);
2916 pe_print_debugdata (abfd
, file
);
2918 rsrc_print_section (abfd
, vfile
);
2924 is_vma_in_section (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sect
, void *obj
)
2926 bfd_vma addr
= * (bfd_vma
*) obj
;
2927 return (addr
>= sect
->vma
) && (addr
< (sect
->vma
+ sect
->size
));
2931 find_section_by_vma (bfd
*abfd
, bfd_vma addr
)
2933 return bfd_sections_find_if (abfd
, is_vma_in_section
, (void *) & addr
);
2936 /* Copy any private info we understand from the input bfd
2937 to the output bfd. */
2940 _bfd_XX_bfd_copy_private_bfd_data_common (bfd
* ibfd
, bfd
* obfd
)
2942 pe_data_type
*ipe
, *ope
;
2944 /* One day we may try to grok other private data. */
2945 if (ibfd
->xvec
->flavour
!= bfd_target_coff_flavour
2946 || obfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
2949 ipe
= pe_data (ibfd
);
2950 ope
= pe_data (obfd
);
2952 /* pe_opthdr is copied in copy_object. */
2953 ope
->dll
= ipe
->dll
;
2955 /* Don't copy input subsystem if output is different from input. */
2956 if (obfd
->xvec
!= ibfd
->xvec
)
2957 ope
->pe_opthdr
.Subsystem
= IMAGE_SUBSYSTEM_UNKNOWN
;
2959 /* For strip: if we removed .reloc, we'll make a real mess of things
2960 if we don't remove this entry as well. */
2961 if (! pe_data (obfd
)->has_reloc_section
)
2963 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].VirtualAddress
= 0;
2964 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].Size
= 0;
2967 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2968 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2970 if (! pe_data (ibfd
)->has_reloc_section
2971 && ! (pe_data (ibfd
)->real_flags
& IMAGE_FILE_RELOCS_STRIPPED
))
2972 pe_data (obfd
)->dont_strip_reloc
= 1;
2974 memcpy (ope
->dos_message
, ipe
->dos_message
, sizeof (ope
->dos_message
));
2976 /* The file offsets contained in the debug directory need rewriting. */
2977 if (ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
!= 0)
2979 bfd_vma addr
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
2980 + ope
->pe_opthdr
.ImageBase
;
2981 asection
*section
= find_section_by_vma (obfd
, addr
);
2984 if (section
&& bfd_malloc_and_get_section (obfd
, section
, &data
))
2987 struct external_IMAGE_DEBUG_DIRECTORY
*dd
=
2988 (struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ (addr
- section
->vma
));
2990 /* PR 17512: file: 0f15796a. */
2991 if ((unsigned long) ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
2992 > section
->size
- (addr
- section
->vma
))
2994 /* xgettext:c-format */
2996 (_("%pB: Data Directory size (%lx) "
2997 "exceeds space left in section (%" PRIx64
")"),
2998 obfd
, ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
,
2999 (uint64_t) (section
->size
- (addr
- section
->vma
)));
3004 for (i
= 0; i
< ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
3005 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
3007 asection
*ddsection
;
3008 struct external_IMAGE_DEBUG_DIRECTORY
*edd
= &(dd
[i
]);
3009 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
3011 _bfd_XXi_swap_debugdir_in (obfd
, edd
, &idd
);
3013 if (idd
.AddressOfRawData
== 0)
3014 continue; /* RVA 0 means only offset is valid, not handled yet. */
3016 ddsection
= find_section_by_vma (obfd
, idd
.AddressOfRawData
+ ope
->pe_opthdr
.ImageBase
);
3018 continue; /* Not in a section! */
3020 idd
.PointerToRawData
= ddsection
->filepos
+ (idd
.AddressOfRawData
3021 + ope
->pe_opthdr
.ImageBase
) - ddsection
->vma
;
3023 _bfd_XXi_swap_debugdir_out (obfd
, &idd
, edd
);
3026 if (!bfd_set_section_contents (obfd
, section
, data
, 0, section
->size
))
3028 _bfd_error_handler (_("failed to update file offsets in debug directory"));
3036 _bfd_error_handler (_("%pB: failed to read debug data section"), obfd
);
3044 /* Copy private section data. */
3047 _bfd_XX_bfd_copy_private_section_data (bfd
*ibfd
,
3052 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
3053 || bfd_get_flavour (obfd
) != bfd_target_coff_flavour
)
3056 if (coff_section_data (ibfd
, isec
) != NULL
3057 && pei_section_data (ibfd
, isec
) != NULL
)
3059 if (coff_section_data (obfd
, osec
) == NULL
)
3061 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
3062 osec
->used_by_bfd
= bfd_zalloc (obfd
, amt
);
3063 if (osec
->used_by_bfd
== NULL
)
3067 if (pei_section_data (obfd
, osec
) == NULL
)
3069 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
3070 coff_section_data (obfd
, osec
)->tdata
= bfd_zalloc (obfd
, amt
);
3071 if (coff_section_data (obfd
, osec
)->tdata
== NULL
)
3075 pei_section_data (obfd
, osec
)->virt_size
=
3076 pei_section_data (ibfd
, isec
)->virt_size
;
3077 pei_section_data (obfd
, osec
)->pe_flags
=
3078 pei_section_data (ibfd
, isec
)->pe_flags
;
3085 _bfd_XX_get_symbol_info (bfd
* abfd
, asymbol
*symbol
, symbol_info
*ret
)
3087 coff_get_symbol_info (abfd
, symbol
, ret
);
3090 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
3092 sort_x64_pdata (const void *l
, const void *r
)
3094 const char *lp
= (const char *) l
;
3095 const char *rp
= (const char *) r
;
3097 vl
= bfd_getl32 (lp
); vr
= bfd_getl32 (rp
);
3099 return (vl
< vr
? -1 : 1);
3100 /* We compare just begin address. */
3105 /* Functions to process a .rsrc section. */
3107 static unsigned int sizeof_leaves
;
3108 static unsigned int sizeof_strings
;
3109 static unsigned int sizeof_tables_and_entries
;
3112 rsrc_count_directory (bfd
*, bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
3115 rsrc_count_entries (bfd
* abfd
,
3116 bfd_boolean is_name
,
3117 bfd_byte
* datastart
,
3122 unsigned long entry
, addr
, size
;
3124 if (data
+ 8 >= dataend
)
3131 entry
= (long) bfd_get_32 (abfd
, data
);
3133 if (HighBitSet (entry
))
3134 name
= datastart
+ WithoutHighBit (entry
);
3136 name
= datastart
+ entry
- rva_bias
;
3138 if (name
+ 2 >= dataend
|| name
< datastart
)
3141 unsigned int len
= bfd_get_16 (abfd
, name
);
3142 if (len
== 0 || len
> 256)
3146 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
3148 if (HighBitSet (entry
))
3150 data
= datastart
+ WithoutHighBit (entry
);
3152 if (data
<= datastart
|| data
>= dataend
)
3155 return rsrc_count_directory (abfd
, datastart
, data
, dataend
, rva_bias
);
3158 if (datastart
+ entry
+ 16 >= dataend
)
3161 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
);
3162 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4);
3164 return datastart
+ addr
- rva_bias
+ size
;
3168 rsrc_count_directory (bfd
* abfd
,
3169 bfd_byte
* datastart
,
3174 unsigned int num_entries
, num_ids
;
3175 bfd_byte
* highest_data
= data
;
3177 if (data
+ 16 >= dataend
)
3180 num_entries
= (int) bfd_get_16 (abfd
, data
+ 12);
3181 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14);
3183 num_entries
+= num_ids
;
3187 while (num_entries
--)
3189 bfd_byte
* entry_end
;
3191 entry_end
= rsrc_count_entries (abfd
, num_entries
>= num_ids
,
3192 datastart
, data
, dataend
, rva_bias
);
3194 highest_data
= max (highest_data
, entry_end
);
3195 if (entry_end
>= dataend
)
3199 return max (highest_data
, data
);
3202 typedef struct rsrc_dir_chain
3204 unsigned int num_entries
;
3205 struct rsrc_entry
* first_entry
;
3206 struct rsrc_entry
* last_entry
;
3209 typedef struct rsrc_directory
3211 unsigned int characteristics
;
3216 rsrc_dir_chain names
;
3219 struct rsrc_entry
* entry
;
3222 typedef struct rsrc_string
3228 typedef struct rsrc_leaf
3231 unsigned int codepage
;
3235 typedef struct rsrc_entry
3237 bfd_boolean is_name
;
3241 struct rsrc_string name
;
3247 struct rsrc_directory
* directory
;
3248 struct rsrc_leaf
* leaf
;
3251 struct rsrc_entry
* next_entry
;
3252 struct rsrc_directory
* parent
;
3256 rsrc_parse_directory (bfd
*, rsrc_directory
*, bfd_byte
*,
3257 bfd_byte
*, bfd_byte
*, bfd_vma
, rsrc_entry
*);
3260 rsrc_parse_entry (bfd
* abfd
,
3261 bfd_boolean is_name
,
3263 bfd_byte
* datastart
,
3267 rsrc_directory
* parent
)
3269 unsigned long val
, addr
, size
;
3271 val
= bfd_get_32 (abfd
, data
);
3273 entry
->parent
= parent
;
3274 entry
->is_name
= is_name
;
3280 if (HighBitSet (val
))
3282 val
= WithoutHighBit (val
);
3284 address
= datastart
+ val
;
3288 address
= datastart
+ val
- rva_bias
;
3291 if (address
+ 3 > dataend
)
3294 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, address
);
3295 entry
->name_id
.name
.string
= address
+ 2;
3298 entry
->name_id
.id
= val
;
3300 val
= bfd_get_32 (abfd
, data
+ 4);
3302 if (HighBitSet (val
))
3304 entry
->is_dir
= TRUE
;
3305 entry
->value
.directory
= bfd_malloc (sizeof * entry
->value
.directory
);
3306 if (entry
->value
.directory
== NULL
)
3309 return rsrc_parse_directory (abfd
, entry
->value
.directory
,
3311 datastart
+ WithoutHighBit (val
),
3312 dataend
, rva_bias
, entry
);
3315 entry
->is_dir
= FALSE
;
3316 entry
->value
.leaf
= bfd_malloc (sizeof * entry
->value
.leaf
);
3317 if (entry
->value
.leaf
== NULL
)
3320 data
= datastart
+ val
;
3321 if (data
< datastart
|| data
>= dataend
)
3324 addr
= bfd_get_32 (abfd
, data
);
3325 size
= entry
->value
.leaf
->size
= bfd_get_32 (abfd
, data
+ 4);
3326 entry
->value
.leaf
->codepage
= bfd_get_32 (abfd
, data
+ 8);
3327 /* FIXME: We assume that the reserved field (data + 12) is OK. */
3329 entry
->value
.leaf
->data
= bfd_malloc (size
);
3330 if (entry
->value
.leaf
->data
== NULL
)
3333 memcpy (entry
->value
.leaf
->data
, datastart
+ addr
- rva_bias
, size
);
3334 return datastart
+ (addr
- rva_bias
) + size
;
3338 rsrc_parse_entries (bfd
* abfd
,
3339 rsrc_dir_chain
* chain
,
3340 bfd_boolean is_name
,
3341 bfd_byte
* highest_data
,
3342 bfd_byte
* datastart
,
3346 rsrc_directory
* parent
)
3351 if (chain
->num_entries
== 0)
3353 chain
->first_entry
= chain
->last_entry
= NULL
;
3354 return highest_data
;
3357 entry
= bfd_malloc (sizeof * entry
);
3361 chain
->first_entry
= entry
;
3363 for (i
= chain
->num_entries
; i
--;)
3365 bfd_byte
* entry_end
;
3367 entry_end
= rsrc_parse_entry (abfd
, is_name
, entry
, datastart
,
3368 data
, dataend
, rva_bias
, parent
);
3370 highest_data
= max (entry_end
, highest_data
);
3371 if (entry_end
> dataend
)
3376 entry
->next_entry
= bfd_malloc (sizeof * entry
);
3377 entry
= entry
->next_entry
;
3382 entry
->next_entry
= NULL
;
3385 chain
->last_entry
= entry
;
3387 return highest_data
;
3391 rsrc_parse_directory (bfd
* abfd
,
3392 rsrc_directory
* table
,
3393 bfd_byte
* datastart
,
3399 bfd_byte
* highest_data
= data
;
3404 table
->characteristics
= bfd_get_32 (abfd
, data
);
3405 table
->time
= bfd_get_32 (abfd
, data
+ 4);
3406 table
->major
= bfd_get_16 (abfd
, data
+ 8);
3407 table
->minor
= bfd_get_16 (abfd
, data
+ 10);
3408 table
->names
.num_entries
= bfd_get_16 (abfd
, data
+ 12);
3409 table
->ids
.num_entries
= bfd_get_16 (abfd
, data
+ 14);
3410 table
->entry
= entry
;
3414 highest_data
= rsrc_parse_entries (abfd
, & table
->names
, TRUE
, data
,
3415 datastart
, data
, dataend
, rva_bias
, table
);
3416 data
+= table
->names
.num_entries
* 8;
3418 highest_data
= rsrc_parse_entries (abfd
, & table
->ids
, FALSE
, highest_data
,
3419 datastart
, data
, dataend
, rva_bias
, table
);
3420 data
+= table
->ids
.num_entries
* 8;
3422 return max (highest_data
, data
);
3425 typedef struct rsrc_write_data
3428 bfd_byte
* datastart
;
3429 bfd_byte
* next_table
;
3430 bfd_byte
* next_leaf
;
3431 bfd_byte
* next_string
;
3432 bfd_byte
* next_data
;
3437 rsrc_write_string (rsrc_write_data
* data
,
3438 rsrc_string
* string
)
3440 bfd_put_16 (data
->abfd
, string
->len
, data
->next_string
);
3441 memcpy (data
->next_string
+ 2, string
->string
, string
->len
* 2);
3442 data
->next_string
+= (string
->len
+ 1) * 2;
3445 static inline unsigned int
3446 rsrc_compute_rva (rsrc_write_data
* data
,
3449 return (addr
- data
->datastart
) + data
->rva_bias
;
3453 rsrc_write_leaf (rsrc_write_data
* data
,
3456 bfd_put_32 (data
->abfd
, rsrc_compute_rva (data
, data
->next_data
),
3458 bfd_put_32 (data
->abfd
, leaf
->size
, data
->next_leaf
+ 4);
3459 bfd_put_32 (data
->abfd
, leaf
->codepage
, data
->next_leaf
+ 8);
3460 bfd_put_32 (data
->abfd
, 0 /*reserved*/, data
->next_leaf
+ 12);
3461 data
->next_leaf
+= 16;
3463 memcpy (data
->next_data
, leaf
->data
, leaf
->size
);
3464 /* An undocumented feature of Windows resources is that each unit
3465 of raw data is 8-byte aligned... */
3466 data
->next_data
+= ((leaf
->size
+ 7) & ~7);
3469 static void rsrc_write_directory (rsrc_write_data
*, rsrc_directory
*);
3472 rsrc_write_entry (rsrc_write_data
* data
,
3478 bfd_put_32 (data
->abfd
,
3479 SetHighBit (data
->next_string
- data
->datastart
),
3481 rsrc_write_string (data
, & entry
->name_id
.name
);
3484 bfd_put_32 (data
->abfd
, entry
->name_id
.id
, where
);
3488 bfd_put_32 (data
->abfd
,
3489 SetHighBit (data
->next_table
- data
->datastart
),
3491 rsrc_write_directory (data
, entry
->value
.directory
);
3495 bfd_put_32 (data
->abfd
, data
->next_leaf
- data
->datastart
, where
+ 4);
3496 rsrc_write_leaf (data
, entry
->value
.leaf
);
3501 rsrc_compute_region_sizes (rsrc_directory
* dir
)
3503 struct rsrc_entry
* entry
;
3508 sizeof_tables_and_entries
+= 16;
3510 for (entry
= dir
->names
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3512 sizeof_tables_and_entries
+= 8;
3514 sizeof_strings
+= (entry
->name_id
.name
.len
+ 1) * 2;
3517 rsrc_compute_region_sizes (entry
->value
.directory
);
3519 sizeof_leaves
+= 16;
3522 for (entry
= dir
->ids
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3524 sizeof_tables_and_entries
+= 8;
3527 rsrc_compute_region_sizes (entry
->value
.directory
);
3529 sizeof_leaves
+= 16;
3534 rsrc_write_directory (rsrc_write_data
* data
,
3535 rsrc_directory
* dir
)
3539 bfd_byte
* next_entry
;
3542 bfd_put_32 (data
->abfd
, dir
->characteristics
, data
->next_table
);
3543 bfd_put_32 (data
->abfd
, 0 /*dir->time*/, data
->next_table
+ 4);
3544 bfd_put_16 (data
->abfd
, dir
->major
, data
->next_table
+ 8);
3545 bfd_put_16 (data
->abfd
, dir
->minor
, data
->next_table
+ 10);
3546 bfd_put_16 (data
->abfd
, dir
->names
.num_entries
, data
->next_table
+ 12);
3547 bfd_put_16 (data
->abfd
, dir
->ids
.num_entries
, data
->next_table
+ 14);
3549 /* Compute where the entries and the next table will be placed. */
3550 next_entry
= data
->next_table
+ 16;
3551 data
->next_table
= next_entry
+ (dir
->names
.num_entries
* 8)
3552 + (dir
->ids
.num_entries
* 8);
3553 nt
= data
->next_table
;
3555 /* Write the entries. */
3556 for (i
= dir
->names
.num_entries
, entry
= dir
->names
.first_entry
;
3557 i
> 0 && entry
!= NULL
;
3558 i
--, entry
= entry
->next_entry
)
3560 BFD_ASSERT (entry
->is_name
);
3561 rsrc_write_entry (data
, next_entry
, entry
);
3564 BFD_ASSERT (i
== 0);
3565 BFD_ASSERT (entry
== NULL
);
3567 for (i
= dir
->ids
.num_entries
, entry
= dir
->ids
.first_entry
;
3568 i
> 0 && entry
!= NULL
;
3569 i
--, entry
= entry
->next_entry
)
3571 BFD_ASSERT (! entry
->is_name
);
3572 rsrc_write_entry (data
, next_entry
, entry
);
3575 BFD_ASSERT (i
== 0);
3576 BFD_ASSERT (entry
== NULL
);
3577 BFD_ASSERT (nt
== next_entry
);
3580 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3581 /* Return the length (number of units) of the first character in S,
3582 putting its 'ucs4_t' representation in *PUC. */
3585 #if defined HAVE_WCTYPE_H
3586 u16_mbtouc (wint_t * puc
, const unsigned short * s
, unsigned int n
)
3588 u16_mbtouc (wchar_t * puc
, const unsigned short * s
, unsigned int n
)
3591 unsigned short c
= * s
;
3593 if (c
< 0xd800 || c
>= 0xe000)
3603 if (s
[1] >= 0xdc00 && s
[1] < 0xe000)
3605 *puc
= 0x10000 + ((c
- 0xd800) << 10) + (s
[1] - 0xdc00);
3611 /* Incomplete multibyte character. */
3617 /* Invalid multibyte character. */
3621 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3623 /* Perform a comparison of two entries. */
3625 rsrc_cmp (bfd_boolean is_name
, rsrc_entry
* a
, rsrc_entry
* b
)
3634 return a
->name_id
.id
- b
->name_id
.id
;
3636 /* We have to perform a case insenstive, unicode string comparison... */
3637 astring
= a
->name_id
.name
.string
;
3638 alen
= a
->name_id
.name
.len
;
3639 bstring
= b
->name_id
.name
.string
;
3640 blen
= b
->name_id
.name
.len
;
3642 #if defined __CYGWIN__ || defined __MINGW32__
3643 /* Under Windows hosts (both Cygwin and Mingw types),
3644 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3645 function however goes by different names in the two environments... */
3649 #define rscpcmp wcsncasecmp
3652 #define rscpcmp wcsnicmp
3655 res
= rscpcmp ((const wchar_t *) astring
, (const wchar_t *) bstring
,
3658 #elif defined HAVE_WCHAR_H
3663 for (i
= min (alen
, blen
); i
--; astring
+= 2, bstring
+= 2)
3665 #if defined HAVE_WCTYPE_H
3673 /* Convert UTF-16 unicode characters into wchar_t characters
3674 so that we can then perform a case insensitive comparison. */
3675 unsigned int Alen
= u16_mbtouc (& awc
, (const unsigned short *) astring
, 2);
3676 unsigned int Blen
= u16_mbtouc (& bwc
, (const unsigned short *) bstring
, 2);
3681 #ifdef HAVE_WCTYPE_H
3682 awc
= towlower (awc
);
3683 bwc
= towlower (bwc
);
3687 res
= wcsncasecmp (& awc
, & bwc
, 1);
3694 /* Do the best we can - a case sensitive, untranslated comparison. */
3695 res
= memcmp (astring
, bstring
, min (alen
, blen
) * 2);
3705 rsrc_print_name (char * buffer
, rsrc_string string
)
3708 bfd_byte
* name
= string
.string
;
3710 for (i
= string
.len
; i
--; name
+= 2)
3711 sprintf (buffer
+ strlen (buffer
), "%.1s", name
);
3715 rsrc_resource_name (rsrc_entry
* entry
, rsrc_directory
* dir
)
3717 static char buffer
[256];
3718 bfd_boolean is_string
= FALSE
;
3722 if (dir
!= NULL
&& dir
->entry
!= NULL
&& dir
->entry
->parent
!= NULL
3723 && dir
->entry
->parent
->entry
!= NULL
)
3725 strcpy (buffer
, "type: ");
3726 if (dir
->entry
->parent
->entry
->is_name
)
3727 rsrc_print_name (buffer
+ strlen (buffer
),
3728 dir
->entry
->parent
->entry
->name_id
.name
);
3731 unsigned int id
= dir
->entry
->parent
->entry
->name_id
.id
;
3733 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3736 case 1: strcat (buffer
, " (CURSOR)"); break;
3737 case 2: strcat (buffer
, " (BITMAP)"); break;
3738 case 3: strcat (buffer
, " (ICON)"); break;
3739 case 4: strcat (buffer
, " (MENU)"); break;
3740 case 5: strcat (buffer
, " (DIALOG)"); break;
3741 case 6: strcat (buffer
, " (STRING)"); is_string
= TRUE
; break;
3742 case 7: strcat (buffer
, " (FONTDIR)"); break;
3743 case 8: strcat (buffer
, " (FONT)"); break;
3744 case 9: strcat (buffer
, " (ACCELERATOR)"); break;
3745 case 10: strcat (buffer
, " (RCDATA)"); break;
3746 case 11: strcat (buffer
, " (MESSAGETABLE)"); break;
3747 case 12: strcat (buffer
, " (GROUP_CURSOR)"); break;
3748 case 14: strcat (buffer
, " (GROUP_ICON)"); break;
3749 case 16: strcat (buffer
, " (VERSION)"); break;
3750 case 17: strcat (buffer
, " (DLGINCLUDE)"); break;
3751 case 19: strcat (buffer
, " (PLUGPLAY)"); break;
3752 case 20: strcat (buffer
, " (VXD)"); break;
3753 case 21: strcat (buffer
, " (ANICURSOR)"); break;
3754 case 22: strcat (buffer
, " (ANIICON)"); break;
3755 case 23: strcat (buffer
, " (HTML)"); break;
3756 case 24: strcat (buffer
, " (MANIFEST)"); break;
3757 case 240: strcat (buffer
, " (DLGINIT)"); break;
3758 case 241: strcat (buffer
, " (TOOLBAR)"); break;
3763 if (dir
!= NULL
&& dir
->entry
!= NULL
)
3765 strcat (buffer
, " name: ");
3766 if (dir
->entry
->is_name
)
3767 rsrc_print_name (buffer
+ strlen (buffer
), dir
->entry
->name_id
.name
);
3770 unsigned int id
= dir
->entry
->name_id
.id
;
3772 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3775 sprintf (buffer
+ strlen (buffer
), " (resource id range: %d - %d)",
3776 (id
- 1) << 4, (id
<< 4) - 1);
3782 strcat (buffer
, " lang: ");
3785 rsrc_print_name (buffer
+ strlen (buffer
), entry
->name_id
.name
);
3787 sprintf (buffer
+ strlen (buffer
), "%x", entry
->name_id
.id
);
3793 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3794 their ID is stored in the NAME entry. The bottom four bits are used as
3795 an index into unicode string table that makes up the data of the leaf.
3796 So identical type-name-lang string resources may not actually be
3799 This function is called when we have detected two string resources with
3800 match top-28-bit IDs. We have to scan the string tables inside the leaves
3801 and discover if there are any real collisions. If there are then we report
3802 them and return FALSE. Otherwise we copy any strings from B into A and
3803 then return TRUE. */
3806 rsrc_merge_string_entries (rsrc_entry
* a ATTRIBUTE_UNUSED
,
3807 rsrc_entry
* b ATTRIBUTE_UNUSED
)
3809 unsigned int copy_needed
= 0;
3813 bfd_byte
* new_data
;
3816 /* Step one: Find out what we have to do. */
3817 BFD_ASSERT (! a
->is_dir
);
3818 astring
= a
->value
.leaf
->data
;
3820 BFD_ASSERT (! b
->is_dir
);
3821 bstring
= b
->value
.leaf
->data
;
3823 for (i
= 0; i
< 16; i
++)
3825 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3826 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3830 copy_needed
+= blen
* 2;
3834 else if (alen
!= blen
)
3835 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3837 /* alen == blen != 0. We might have two identical strings. If so we
3838 can ignore the second one. There is no need for wchar_t vs UTF-16
3839 theatrics here - we are only interested in (case sensitive) equality. */
3840 else if (memcmp (astring
+ 2, bstring
+ 2, alen
* 2) != 0)
3843 astring
+= (alen
+ 1) * 2;
3844 bstring
+= (blen
+ 1) * 2;
3849 if (a
->parent
!= NULL
3850 && a
->parent
->entry
!= NULL
3851 && !a
->parent
->entry
->is_name
)
3852 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3853 ((a
->parent
->entry
->name_id
.id
- 1) << 4) + i
);
3857 if (copy_needed
== 0)
3860 /* If we reach here then A and B must both have non-colliding strings.
3861 (We never get string resources with fully empty string tables).
3862 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3864 new_data
= bfd_malloc (a
->value
.leaf
->size
+ copy_needed
);
3865 if (new_data
== NULL
)
3869 astring
= a
->value
.leaf
->data
;
3870 bstring
= b
->value
.leaf
->data
;
3872 for (i
= 0; i
< 16; i
++)
3874 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3875 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3879 memcpy (nstring
, astring
, (alen
+ 1) * 2);
3880 nstring
+= (alen
+ 1) * 2;
3884 memcpy (nstring
, bstring
, (blen
+ 1) * 2);
3885 nstring
+= (blen
+ 1) * 2;
3893 astring
+= (alen
+ 1) * 2;
3894 bstring
+= (blen
+ 1) * 2;
3897 BFD_ASSERT (nstring
- new_data
== (signed) (a
->value
.leaf
->size
+ copy_needed
));
3899 free (a
->value
.leaf
->data
);
3900 a
->value
.leaf
->data
= new_data
;
3901 a
->value
.leaf
->size
+= copy_needed
;
3906 static void rsrc_merge (rsrc_entry
*, rsrc_entry
*);
3908 /* Sort the entries in given part of the directory.
3909 We use an old fashioned bubble sort because we are dealing
3910 with lists and we want to handle matches specially. */
3913 rsrc_sort_entries (rsrc_dir_chain
* chain
,
3914 bfd_boolean is_name
,
3915 rsrc_directory
* dir
)
3919 rsrc_entry
** points_to_entry
;
3920 bfd_boolean swapped
;
3922 if (chain
->num_entries
< 2)
3928 points_to_entry
= & chain
->first_entry
;
3929 entry
= * points_to_entry
;
3930 next
= entry
->next_entry
;
3934 signed int cmp
= rsrc_cmp (is_name
, entry
, next
);
3938 entry
->next_entry
= next
->next_entry
;
3939 next
->next_entry
= entry
;
3940 * points_to_entry
= next
;
3941 points_to_entry
= & next
->next_entry
;
3942 next
= entry
->next_entry
;
3947 if (entry
->is_dir
&& next
->is_dir
)
3949 /* When we encounter identical directory entries we have to
3950 merge them together. The exception to this rule is for
3951 resource manifests - there can only be one of these,
3952 even if they differ in language. Zero-language manifests
3953 are assumed to be default manifests (provided by the
3954 Cygwin/MinGW build system) and these can be silently dropped,
3955 unless that would reduce the number of manifests to zero.
3956 There should only ever be one non-zero lang manifest -
3957 if there are more it is an error. A non-zero lang
3958 manifest takes precedence over a default manifest. */
3960 && entry
->name_id
.id
== 1
3962 && dir
->entry
!= NULL
3963 && !dir
->entry
->is_name
3964 && dir
->entry
->name_id
.id
== 0x18)
3966 if (next
->value
.directory
->names
.num_entries
== 0
3967 && next
->value
.directory
->ids
.num_entries
== 1
3968 && !next
->value
.directory
->ids
.first_entry
->is_name
3969 && next
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3970 /* Fall through so that NEXT is dropped. */
3972 else if (entry
->value
.directory
->names
.num_entries
== 0
3973 && entry
->value
.directory
->ids
.num_entries
== 1
3974 && !entry
->value
.directory
->ids
.first_entry
->is_name
3975 && entry
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3977 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
3978 entry
->next_entry
= next
->next_entry
;
3979 next
->next_entry
= entry
;
3980 * points_to_entry
= next
;
3981 points_to_entry
= & next
->next_entry
;
3982 next
= entry
->next_entry
;
3987 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3988 bfd_set_error (bfd_error_file_truncated
);
3992 /* Unhook NEXT from the chain. */
3993 /* FIXME: memory loss here. */
3994 entry
->next_entry
= next
->next_entry
;
3995 chain
->num_entries
--;
3996 if (chain
->num_entries
< 2)
3998 next
= next
->next_entry
;
4001 rsrc_merge (entry
, next
);
4003 else if (entry
->is_dir
!= next
->is_dir
)
4005 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
4006 bfd_set_error (bfd_error_file_truncated
);
4011 /* Otherwise with identical leaves we issue an error
4012 message - because there should never be duplicates.
4013 The exception is Type 18/Name 1/Lang 0 which is the
4014 defaul manifest - this can just be dropped. */
4016 && entry
->name_id
.id
== 0
4018 && dir
->entry
!= NULL
4019 && !dir
->entry
->is_name
4020 && dir
->entry
->name_id
.id
== 1
4021 && dir
->entry
->parent
!= NULL
4022 && dir
->entry
->parent
->entry
!= NULL
4023 && !dir
->entry
->parent
->entry
->is_name
4024 && dir
->entry
->parent
->entry
->name_id
.id
== 0x18 /* RT_MANIFEST */)
4026 else if (dir
!= NULL
4027 && dir
->entry
!= NULL
4028 && dir
->entry
->parent
!= NULL
4029 && dir
->entry
->parent
->entry
!= NULL
4030 && !dir
->entry
->parent
->entry
->is_name
4031 && dir
->entry
->parent
->entry
->name_id
.id
== 0x6 /* RT_STRING */)
4033 /* Strings need special handling. */
4034 if (! rsrc_merge_string_entries (entry
, next
))
4036 /* _bfd_error_handler should have been called inside merge_strings. */
4037 bfd_set_error (bfd_error_file_truncated
);
4044 || dir
->entry
== NULL
4045 || dir
->entry
->parent
== NULL
4046 || dir
->entry
->parent
->entry
== NULL
)
4047 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
4049 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
4050 rsrc_resource_name (entry
, dir
));
4051 bfd_set_error (bfd_error_file_truncated
);
4056 /* Unhook NEXT from the chain. */
4057 entry
->next_entry
= next
->next_entry
;
4058 chain
->num_entries
--;
4059 if (chain
->num_entries
< 2)
4061 next
= next
->next_entry
;
4065 points_to_entry
= & entry
->next_entry
;
4067 next
= next
->next_entry
;
4072 chain
->last_entry
= entry
;
4077 /* Attach B's chain onto A. */
4079 rsrc_attach_chain (rsrc_dir_chain
* achain
, rsrc_dir_chain
* bchain
)
4081 if (bchain
->num_entries
== 0)
4084 achain
->num_entries
+= bchain
->num_entries
;
4086 if (achain
->first_entry
== NULL
)
4088 achain
->first_entry
= bchain
->first_entry
;
4089 achain
->last_entry
= bchain
->last_entry
;
4093 achain
->last_entry
->next_entry
= bchain
->first_entry
;
4094 achain
->last_entry
= bchain
->last_entry
;
4097 bchain
->num_entries
= 0;
4098 bchain
->first_entry
= bchain
->last_entry
= NULL
;
4102 rsrc_merge (struct rsrc_entry
* a
, struct rsrc_entry
* b
)
4104 rsrc_directory
* adir
;
4105 rsrc_directory
* bdir
;
4107 BFD_ASSERT (a
->is_dir
);
4108 BFD_ASSERT (b
->is_dir
);
4110 adir
= a
->value
.directory
;
4111 bdir
= b
->value
.directory
;
4113 if (adir
->characteristics
!= bdir
->characteristics
)
4115 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics"));
4116 bfd_set_error (bfd_error_file_truncated
);
4120 if (adir
->major
!= bdir
->major
|| adir
->minor
!= bdir
->minor
)
4122 _bfd_error_handler (_(".rsrc merge failure: differing directory versions"));
4123 bfd_set_error (bfd_error_file_truncated
);
4127 /* Attach B's name chain to A. */
4128 rsrc_attach_chain (& adir
->names
, & bdir
->names
);
4130 /* Attach B's ID chain to A. */
4131 rsrc_attach_chain (& adir
->ids
, & bdir
->ids
);
4133 /* Now sort A's entries. */
4134 rsrc_sort_entries (& adir
->names
, TRUE
, adir
);
4135 rsrc_sort_entries (& adir
->ids
, FALSE
, adir
);
4138 /* Check the .rsrc section. If it contains multiple concatenated
4139 resources then we must merge them properly. Otherwise Windows
4140 will ignore all but the first set. */
4143 rsrc_process_section (bfd
* abfd
,
4144 struct coff_final_link_info
* pfinfo
)
4146 rsrc_directory new_table
;
4152 bfd_byte
* datastart
;
4154 bfd_byte
* new_data
;
4155 unsigned int num_resource_sets
;
4156 rsrc_directory
* type_tables
;
4157 rsrc_write_data write_data
;
4160 unsigned int num_input_rsrc
= 0;
4161 unsigned int max_num_input_rsrc
= 4;
4162 ptrdiff_t * rsrc_sizes
= NULL
;
4164 new_table
.names
.num_entries
= 0;
4165 new_table
.ids
.num_entries
= 0;
4167 sec
= bfd_get_section_by_name (abfd
, ".rsrc");
4168 if (sec
== NULL
|| (size
= sec
->rawsize
) == 0)
4171 pe
= pe_data (abfd
);
4175 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4177 data
= bfd_malloc (size
);
4183 if (! bfd_get_section_contents (abfd
, sec
, data
, 0, size
))
4186 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4187 their lengths. Note - we rely upon the fact that the linker script
4188 does *not* sort the input .rsrc sections, so that the order in the
4189 linkinfo list matches the order in the output .rsrc section.
4191 We need to know the lengths because each input .rsrc section has padding
4192 at the end of a variable amount. (It does not appear to be based upon
4193 the section alignment or the file alignment). We need to skip any
4194 padding bytes when parsing the input .rsrc sections. */
4195 rsrc_sizes
= bfd_malloc (max_num_input_rsrc
* sizeof * rsrc_sizes
);
4196 if (rsrc_sizes
== NULL
)
4199 for (input
= pfinfo
->info
->input_bfds
;
4201 input
= input
->link
.next
)
4203 asection
* rsrc_sec
= bfd_get_section_by_name (input
, ".rsrc");
4205 /* PR 18372 - skip discarded .rsrc sections. */
4206 if (rsrc_sec
!= NULL
&& !discarded_section (rsrc_sec
))
4208 if (num_input_rsrc
== max_num_input_rsrc
)
4210 max_num_input_rsrc
+= 10;
4211 rsrc_sizes
= bfd_realloc (rsrc_sizes
, max_num_input_rsrc
4212 * sizeof * rsrc_sizes
);
4213 if (rsrc_sizes
== NULL
)
4217 BFD_ASSERT (rsrc_sec
->size
> 0);
4218 rsrc_sizes
[num_input_rsrc
++] = rsrc_sec
->size
;
4222 if (num_input_rsrc
< 2)
4225 /* Step one: Walk the section, computing the size of the tables,
4226 leaves and data and decide if we need to do anything. */
4227 dataend
= data
+ size
;
4228 num_resource_sets
= 0;
4230 while (data
< dataend
)
4232 bfd_byte
* p
= data
;
4234 data
= rsrc_count_directory (abfd
, data
, data
, dataend
, rva_bias
);
4238 /* Corrupted .rsrc section - cannot merge. */
4239 _bfd_error_handler (_("%pB: .rsrc merge failure: corrupt .rsrc section"),
4241 bfd_set_error (bfd_error_file_truncated
);
4245 if ((data
- p
) > rsrc_sizes
[num_resource_sets
])
4247 _bfd_error_handler (_("%pB: .rsrc merge failure: unexpected .rsrc size"),
4249 bfd_set_error (bfd_error_file_truncated
);
4252 /* FIXME: Should we add a check for "data - p" being much smaller
4253 than rsrc_sizes[num_resource_sets] ? */
4255 data
= p
+ rsrc_sizes
[num_resource_sets
];
4256 rva_bias
+= data
- p
;
4257 ++ num_resource_sets
;
4259 BFD_ASSERT (num_resource_sets
== num_input_rsrc
);
4261 /* Step two: Walk the data again, building trees of the resources. */
4263 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4265 type_tables
= bfd_malloc (num_resource_sets
* sizeof * type_tables
);
4266 if (type_tables
== NULL
)
4270 while (data
< dataend
)
4272 bfd_byte
* p
= data
;
4274 (void) rsrc_parse_directory (abfd
, type_tables
+ indx
, data
, data
,
4275 dataend
, rva_bias
, NULL
);
4276 data
= p
+ rsrc_sizes
[indx
];
4277 rva_bias
+= data
- p
;
4280 BFD_ASSERT (indx
== num_resource_sets
);
4282 /* Step three: Merge the top level tables (there can be only one).
4284 We must ensure that the merged entries are in ascending order.
4286 We also thread the top level table entries from the old tree onto
4287 the new table, so that they can be pulled off later. */
4289 /* FIXME: Should we verify that all type tables are the same ? */
4290 new_table
.characteristics
= type_tables
[0].characteristics
;
4291 new_table
.time
= type_tables
[0].time
;
4292 new_table
.major
= type_tables
[0].major
;
4293 new_table
.minor
= type_tables
[0].minor
;
4295 /* Chain the NAME entries onto the table. */
4296 new_table
.names
.first_entry
= NULL
;
4297 new_table
.names
.last_entry
= NULL
;
4299 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4300 rsrc_attach_chain (& new_table
.names
, & type_tables
[indx
].names
);
4302 rsrc_sort_entries (& new_table
.names
, TRUE
, & new_table
);
4304 /* Chain the ID entries onto the table. */
4305 new_table
.ids
.first_entry
= NULL
;
4306 new_table
.ids
.last_entry
= NULL
;
4308 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4309 rsrc_attach_chain (& new_table
.ids
, & type_tables
[indx
].ids
);
4311 rsrc_sort_entries (& new_table
.ids
, FALSE
, & new_table
);
4313 /* Step four: Create new contents for the .rsrc section. */
4314 /* Step four point one: Compute the size of each region of the .rsrc section.
4315 We do this now, rather than earlier, as the merging above may have dropped
4317 sizeof_leaves
= sizeof_strings
= sizeof_tables_and_entries
= 0;
4318 rsrc_compute_region_sizes (& new_table
);
4319 /* We increment sizeof_strings to make sure that resource data
4320 starts on an 8-byte boundary. FIXME: Is this correct ? */
4321 sizeof_strings
= (sizeof_strings
+ 7) & ~ 7;
4323 new_data
= bfd_zalloc (abfd
, size
);
4324 if (new_data
== NULL
)
4327 write_data
.abfd
= abfd
;
4328 write_data
.datastart
= new_data
;
4329 write_data
.next_table
= new_data
;
4330 write_data
.next_leaf
= new_data
+ sizeof_tables_and_entries
;
4331 write_data
.next_string
= write_data
.next_leaf
+ sizeof_leaves
;
4332 write_data
.next_data
= write_data
.next_string
+ sizeof_strings
;
4333 write_data
.rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4335 rsrc_write_directory (& write_data
, & new_table
);
4337 /* Step five: Replace the old contents with the new.
4338 We don't recompute the size as it's too late here to shrink section.
4339 See PR ld/20193 for more details. */
4340 bfd_set_section_contents (pfinfo
->output_bfd
, sec
, new_data
, 0, size
);
4341 sec
->size
= sec
->rawsize
= size
;
4344 /* Step six: Free all the memory that we have used. */
4345 /* FIXME: Free the resource tree, if we have one. */
4350 /* Handle the .idata section and other things that need symbol table
4354 _bfd_XXi_final_link_postscript (bfd
* abfd
, struct coff_final_link_info
*pfinfo
)
4356 struct coff_link_hash_entry
*h1
;
4357 struct bfd_link_info
*info
= pfinfo
->info
;
4358 bfd_boolean result
= TRUE
;
4360 /* There are a few fields that need to be filled in now while we
4361 have symbol table access.
4363 The .idata subsections aren't directly available as sections, but
4364 they are in the symbol table, so get them from there. */
4366 /* The import directory. This is the address of .idata$2, with size
4367 of .idata$2 + .idata$3. */
4368 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4369 ".idata$2", FALSE
, FALSE
, TRUE
);
4372 /* PR ld/2729: We cannot rely upon all the output sections having been
4373 created properly, so check before referencing them. Issue a warning
4374 message for any sections tht could not be found. */
4375 if ((h1
->root
.type
== bfd_link_hash_defined
4376 || h1
->root
.type
== bfd_link_hash_defweak
)
4377 && h1
->root
.u
.def
.section
!= NULL
4378 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4379 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
=
4380 (h1
->root
.u
.def
.value
4381 + h1
->root
.u
.def
.section
->output_section
->vma
4382 + h1
->root
.u
.def
.section
->output_offset
);
4386 (_("%pB: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4391 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4392 ".idata$4", FALSE
, FALSE
, TRUE
);
4394 && (h1
->root
.type
== bfd_link_hash_defined
4395 || h1
->root
.type
== bfd_link_hash_defweak
)
4396 && h1
->root
.u
.def
.section
!= NULL
4397 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4398 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].Size
=
4399 ((h1
->root
.u
.def
.value
4400 + h1
->root
.u
.def
.section
->output_section
->vma
4401 + h1
->root
.u
.def
.section
->output_offset
)
4402 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
);
4406 (_("%pB: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4411 /* The import address table. This is the size/address of
4413 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4414 ".idata$5", FALSE
, FALSE
, TRUE
);
4416 && (h1
->root
.type
== bfd_link_hash_defined
4417 || h1
->root
.type
== bfd_link_hash_defweak
)
4418 && h1
->root
.u
.def
.section
!= NULL
4419 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4420 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4421 (h1
->root
.u
.def
.value
4422 + h1
->root
.u
.def
.section
->output_section
->vma
4423 + h1
->root
.u
.def
.section
->output_offset
);
4427 (_("%pB: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4432 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4433 ".idata$6", FALSE
, FALSE
, TRUE
);
4435 && (h1
->root
.type
== bfd_link_hash_defined
4436 || h1
->root
.type
== bfd_link_hash_defweak
)
4437 && h1
->root
.u
.def
.section
!= NULL
4438 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4439 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4440 ((h1
->root
.u
.def
.value
4441 + h1
->root
.u
.def
.section
->output_section
->vma
4442 + h1
->root
.u
.def
.section
->output_offset
)
4443 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
);
4447 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4454 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4455 "__IAT_start__", FALSE
, FALSE
, TRUE
);
4457 && (h1
->root
.type
== bfd_link_hash_defined
4458 || h1
->root
.type
== bfd_link_hash_defweak
)
4459 && h1
->root
.u
.def
.section
!= NULL
4460 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4465 (h1
->root
.u
.def
.value
4466 + h1
->root
.u
.def
.section
->output_section
->vma
4467 + h1
->root
.u
.def
.section
->output_offset
);
4469 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4470 "__IAT_end__", FALSE
, FALSE
, TRUE
);
4472 && (h1
->root
.type
== bfd_link_hash_defined
4473 || h1
->root
.type
== bfd_link_hash_defweak
)
4474 && h1
->root
.u
.def
.section
!= NULL
4475 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4477 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4478 ((h1
->root
.u
.def
.value
4479 + h1
->root
.u
.def
.section
->output_section
->vma
4480 + h1
->root
.u
.def
.section
->output_offset
)
4482 if (pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
!= 0)
4483 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4484 iat_va
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
4489 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4490 " because .idata$6 is missing"), abfd
);
4496 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4497 (bfd_get_symbol_leading_char (abfd
) != 0
4498 ? "__tls_used" : "_tls_used"),
4499 FALSE
, FALSE
, TRUE
);
4502 if ((h1
->root
.type
== bfd_link_hash_defined
4503 || h1
->root
.type
== bfd_link_hash_defweak
)
4504 && h1
->root
.u
.def
.section
!= NULL
4505 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4506 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].VirtualAddress
=
4507 (h1
->root
.u
.def
.value
4508 + h1
->root
.u
.def
.section
->output_section
->vma
4509 + h1
->root
.u
.def
.section
->output_offset
4510 - pe_data (abfd
)->pe_opthdr
.ImageBase
);
4514 (_("%pB: unable to fill in DataDictionary[9] because __tls_used is missing"),
4518 /* According to PECOFF sepcifications by Microsoft version 8.2
4519 the TLS data directory consists of 4 pointers, followed
4520 by two 4-byte integer. This implies that the total size
4521 is different for 32-bit and 64-bit executables. */
4522 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4523 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x18;
4525 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x28;
4529 /* If there is a .pdata section and we have linked pdata finally, we
4530 need to sort the entries ascending. */
4531 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4533 asection
*sec
= bfd_get_section_by_name (abfd
, ".pdata");
4537 bfd_size_type x
= sec
->rawsize
;
4538 bfd_byte
*tmp_data
= NULL
;
4541 tmp_data
= bfd_malloc (x
);
4543 if (tmp_data
!= NULL
)
4545 if (bfd_get_section_contents (abfd
, sec
, tmp_data
, 0, x
))
4549 12, sort_x64_pdata
);
4550 bfd_set_section_contents (pfinfo
->output_bfd
, sec
,
4561 rsrc_process_section (abfd
, pfinfo
);
4563 /* If we couldn't find idata$2, we either have an excessively
4564 trivial program or are in DEEP trouble; we have to assume trivial