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;
183 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
184 if (unused_section_number
<= sec
->target_index
)
185 unused_section_number
= sec
->target_index
+ 1;
187 name_len
= strlen (name
) + 1;
188 sec_name
= bfd_alloc (abfd
, name_len
);
189 if (sec_name
== NULL
)
191 _bfd_error_handler (_("%pB: out of memory creating name "
192 "for empty section"), abfd
);
195 memcpy (sec_name
, name
, name_len
);
197 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_DATA
| SEC_LOAD
;
198 sec
= bfd_make_section_anyway_with_flags (abfd
, sec_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
)->timestamp
) == -1)
880 H_PUT_32 (abfd
, time (0), filehdr_out
->f_timdat
);
882 H_PUT_32 (abfd
, pe_data (abfd
)->timestamp
, 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
)
1150 bfd_size_type nread
;
1152 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1155 if (length
<= sizeof (CV_INFO_PDB70
) && length
<= sizeof (CV_INFO_PDB20
))
1159 nread
= bfd_bread (buffer
, length
, abfd
);
1160 if (length
!= nread
)
1163 /* Ensure null termination of filename. */
1164 memset (buffer
+ nread
, 0, sizeof (buffer
) - nread
);
1166 cvinfo
->CVSignature
= H_GET_32 (abfd
, buffer
);
1169 if ((cvinfo
->CVSignature
== CVINFO_PDB70_CVSIGNATURE
)
1170 && (length
> sizeof (CV_INFO_PDB70
)))
1172 CV_INFO_PDB70
*cvinfo70
= (CV_INFO_PDB70
*)(buffer
);
1174 cvinfo
->Age
= H_GET_32(abfd
, cvinfo70
->Age
);
1176 /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1177 by 8 single bytes. Byte swap them so we can conveniently treat the GUID
1178 as 16 bytes in big-endian order. */
1179 bfd_putb32 (bfd_getl32 (cvinfo70
->Signature
), cvinfo
->Signature
);
1180 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[4])), &(cvinfo
->Signature
[4]));
1181 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[6])), &(cvinfo
->Signature
[6]));
1182 memcpy (&(cvinfo
->Signature
[8]), &(cvinfo70
->Signature
[8]), 8);
1184 cvinfo
->SignatureLength
= CV_INFO_SIGNATURE_LENGTH
;
1185 /* cvinfo->PdbFileName = cvinfo70->PdbFileName; */
1189 else if ((cvinfo
->CVSignature
== CVINFO_PDB20_CVSIGNATURE
)
1190 && (length
> sizeof (CV_INFO_PDB20
)))
1192 CV_INFO_PDB20
*cvinfo20
= (CV_INFO_PDB20
*)(buffer
);
1193 cvinfo
->Age
= H_GET_32(abfd
, cvinfo20
->Age
);
1194 memcpy (cvinfo
->Signature
, cvinfo20
->Signature
, 4);
1195 cvinfo
->SignatureLength
= 4;
1196 /* cvinfo->PdbFileName = cvinfo20->PdbFileName; */
1205 _bfd_XXi_write_codeview_record (bfd
* abfd
, file_ptr where
, CODEVIEW_INFO
*cvinfo
)
1207 const bfd_size_type size
= sizeof (CV_INFO_PDB70
) + 1;
1208 bfd_size_type written
;
1209 CV_INFO_PDB70
*cvinfo70
;
1212 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1215 buffer
= bfd_malloc (size
);
1219 cvinfo70
= (CV_INFO_PDB70
*) buffer
;
1220 H_PUT_32 (abfd
, CVINFO_PDB70_CVSIGNATURE
, cvinfo70
->CvSignature
);
1222 /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1223 in little-endian order, followed by 8 single bytes. */
1224 bfd_putl32 (bfd_getb32 (cvinfo
->Signature
), cvinfo70
->Signature
);
1225 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[4])), &(cvinfo70
->Signature
[4]));
1226 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[6])), &(cvinfo70
->Signature
[6]));
1227 memcpy (&(cvinfo70
->Signature
[8]), &(cvinfo
->Signature
[8]), 8);
1229 H_PUT_32 (abfd
, cvinfo
->Age
, cvinfo70
->Age
);
1230 cvinfo70
->PdbFileName
[0] = '\0';
1232 written
= bfd_bwrite (buffer
, size
, abfd
);
1236 return written
== size
? size
: 0;
1239 static char * dir_names
[IMAGE_NUMBEROF_DIRECTORY_ENTRIES
] =
1241 N_("Export Directory [.edata (or where ever we found it)]"),
1242 N_("Import Directory [parts of .idata]"),
1243 N_("Resource Directory [.rsrc]"),
1244 N_("Exception Directory [.pdata]"),
1245 N_("Security Directory"),
1246 N_("Base Relocation Directory [.reloc]"),
1247 N_("Debug Directory"),
1248 N_("Description Directory"),
1249 N_("Special Directory"),
1250 N_("Thread Storage Directory [.tls]"),
1251 N_("Load Configuration Directory"),
1252 N_("Bound Import Directory"),
1253 N_("Import Address Table Directory"),
1254 N_("Delay Import Directory"),
1255 N_("CLR Runtime Header"),
1259 #ifdef POWERPC_LE_PE
1260 /* The code for the PPC really falls in the "architecture dependent"
1261 category. However, it's not clear that anyone will ever care, so
1262 we're ignoring the issue for now; if/when PPC matters, some of this
1263 may need to go into peicode.h, or arguments passed to enable the
1264 PPC- specific code. */
1268 pe_print_idata (bfd
* abfd
, void * vfile
)
1270 FILE *file
= (FILE *) vfile
;
1275 #ifdef POWERPC_LE_PE
1276 asection
*rel_section
= bfd_get_section_by_name (abfd
, ".reldata");
1279 bfd_size_type datasize
= 0;
1280 bfd_size_type dataoff
;
1284 pe_data_type
*pe
= pe_data (abfd
);
1285 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1289 addr
= extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
;
1291 if (addr
== 0 && extra
->DataDirectory
[PE_IMPORT_TABLE
].Size
== 0)
1293 /* Maybe the extra header isn't there. Look for the section. */
1294 section
= bfd_get_section_by_name (abfd
, ".idata");
1295 if (section
== NULL
)
1298 addr
= section
->vma
;
1299 datasize
= section
->size
;
1305 addr
+= extra
->ImageBase
;
1306 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1308 datasize
= section
->size
;
1309 if (addr
>= section
->vma
&& addr
< section
->vma
+ datasize
)
1313 if (section
== NULL
)
1316 _("\nThere is an import table, but the section containing it could not be found\n"));
1319 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1322 _("\nThere is an import table in %s, but that section has no contents\n"),
1328 /* xgettext:c-format */
1329 fprintf (file
, _("\nThere is an import table in %s at 0x%lx\n"),
1330 section
->name
, (unsigned long) addr
);
1332 dataoff
= addr
- section
->vma
;
1334 #ifdef POWERPC_LE_PE
1335 if (rel_section
!= 0 && rel_section
->size
!= 0)
1337 /* The toc address can be found by taking the starting address,
1338 which on the PPC locates a function descriptor. The
1339 descriptor consists of the function code starting address
1340 followed by the address of the toc. The starting address we
1341 get from the bfd, and the descriptor is supposed to be in the
1342 .reldata section. */
1344 bfd_vma loadable_toc_address
;
1345 bfd_vma toc_address
;
1346 bfd_vma start_address
;
1350 if (!bfd_malloc_and_get_section (abfd
, rel_section
, &data
))
1356 offset
= abfd
->start_address
- rel_section
->vma
;
1358 if (offset
>= rel_section
->size
|| offset
+ 8 > rel_section
->size
)
1364 start_address
= bfd_get_32 (abfd
, data
+ offset
);
1365 loadable_toc_address
= bfd_get_32 (abfd
, data
+ offset
+ 4);
1366 toc_address
= loadable_toc_address
- 32768;
1369 _("\nFunction descriptor located at the start address: %04lx\n"),
1370 (unsigned long int) (abfd
->start_address
));
1372 /* xgettext:c-format */
1373 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1374 start_address
, loadable_toc_address
, toc_address
);
1380 _("\nNo reldata section! Function descriptor not decoded.\n"));
1385 _("\nThe Import Tables (interpreted %s section contents)\n"),
1389 vma: Hint Time Forward DLL First\n\
1390 Table Stamp Chain Name Thunk\n"));
1392 /* Read the whole section. Some of the fields might be before dataoff. */
1393 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
1399 adj
= section
->vma
- extra
->ImageBase
;
1401 /* Print all image import descriptors. */
1402 for (i
= dataoff
; i
+ onaline
<= datasize
; i
+= onaline
)
1406 bfd_vma forward_chain
;
1408 bfd_vma first_thunk
;
1413 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1414 fprintf (file
, " %08lx\t", (unsigned long) (i
+ adj
));
1415 hint_addr
= bfd_get_32 (abfd
, data
+ i
);
1416 time_stamp
= bfd_get_32 (abfd
, data
+ i
+ 4);
1417 forward_chain
= bfd_get_32 (abfd
, data
+ i
+ 8);
1418 dll_name
= bfd_get_32 (abfd
, data
+ i
+ 12);
1419 first_thunk
= bfd_get_32 (abfd
, data
+ i
+ 16);
1421 fprintf (file
, "%08lx %08lx %08lx %08lx %08lx\n",
1422 (unsigned long) hint_addr
,
1423 (unsigned long) time_stamp
,
1424 (unsigned long) forward_chain
,
1425 (unsigned long) dll_name
,
1426 (unsigned long) first_thunk
);
1428 if (hint_addr
== 0 && first_thunk
== 0)
1431 if (dll_name
- adj
>= section
->size
)
1434 dll
= (char *) data
+ dll_name
- adj
;
1435 /* PR 17512 file: 078-12277-0.004. */
1436 bfd_size_type maxlen
= (char *)(data
+ datasize
) - dll
- 1;
1437 fprintf (file
, _("\n\tDLL Name: %.*s\n"), (int) maxlen
, dll
);
1439 /* PR 21546: When the Hint Address is zero,
1440 we try the First Thunk instead. */
1442 hint_addr
= first_thunk
;
1444 if (hint_addr
!= 0 && hint_addr
- adj
< datasize
)
1447 asection
*ft_section
;
1449 bfd_size_type ft_datasize
;
1453 fprintf (file
, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1455 idx
= hint_addr
- adj
;
1457 ft_addr
= first_thunk
+ extra
->ImageBase
;
1458 ft_idx
= first_thunk
- adj
;
1459 ft_data
= data
+ ft_idx
;
1460 ft_datasize
= datasize
- ft_idx
;
1463 if (first_thunk
!= hint_addr
)
1465 /* Find the section which contains the first thunk. */
1466 for (ft_section
= abfd
->sections
;
1468 ft_section
= ft_section
->next
)
1470 if (ft_addr
>= ft_section
->vma
1471 && ft_addr
< ft_section
->vma
+ ft_section
->size
)
1475 if (ft_section
== NULL
)
1478 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1482 /* Now check to see if this section is the same as our current
1483 section. If it is not then we will have to load its data in. */
1484 if (ft_section
!= section
)
1486 ft_idx
= first_thunk
- (ft_section
->vma
- extra
->ImageBase
);
1487 ft_datasize
= ft_section
->size
- ft_idx
;
1488 ft_data
= (bfd_byte
*) bfd_malloc (ft_datasize
);
1489 if (ft_data
== NULL
)
1492 /* Read ft_datasize bytes starting at offset ft_idx. */
1493 if (!bfd_get_section_contents (abfd
, ft_section
, ft_data
,
1494 (bfd_vma
) ft_idx
, ft_datasize
))
1503 /* Print HintName vector entries. */
1504 #ifdef COFF_WITH_pex64
1505 for (j
= 0; idx
+ j
+ 8 <= datasize
; j
+= 8)
1508 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1509 unsigned long member_high
= bfd_get_32 (abfd
, data
+ idx
+ j
+ 4);
1511 if (!member
&& !member_high
)
1516 if (HighBitSet (member_high
))
1517 fprintf (file
, "\t%lx%08lx\t %4lx%08lx <none>",
1518 member_high
, member
,
1519 WithoutHighBit (member_high
), member
);
1520 /* PR binutils/17512: Handle corrupt PE data. */
1521 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1522 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1528 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1529 member_name
= (char *) data
+ amt
+ 2;
1530 fprintf (file
, "\t%04lx\t %4d %.*s",member
, ordinal
,
1531 (int) (datasize
- (amt
+ 2)), member_name
);
1534 /* If the time stamp is not zero, the import address
1535 table holds actual addresses. */
1538 && first_thunk
!= hint_addr
1539 && j
+ 4 <= ft_datasize
)
1540 fprintf (file
, "\t%04lx",
1541 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1542 fprintf (file
, "\n");
1545 for (j
= 0; idx
+ j
+ 4 <= datasize
; j
+= 4)
1548 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1550 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1556 if (HighBitSet (member
))
1557 fprintf (file
, "\t%04lx\t %4lu <none>",
1558 member
, WithoutHighBit (member
));
1559 /* PR binutils/17512: Handle corrupt PE data. */
1560 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1561 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1567 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1568 member_name
= (char *) data
+ amt
+ 2;
1569 fprintf (file
, "\t%04lx\t %4d %.*s",
1571 (int) (datasize
- (amt
+ 2)), member_name
);
1574 /* If the time stamp is not zero, the import address
1575 table holds actual addresses. */
1578 && first_thunk
!= hint_addr
1579 && j
+ 4 <= ft_datasize
)
1580 fprintf (file
, "\t%04lx",
1581 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1583 fprintf (file
, "\n");
1590 fprintf (file
, "\n");
1599 pe_print_edata (bfd
* abfd
, void * vfile
)
1601 FILE *file
= (FILE *) vfile
;
1604 bfd_size_type datasize
= 0;
1605 bfd_size_type dataoff
;
1610 long export_flags
; /* Reserved - should be zero. */
1614 bfd_vma name
; /* RVA - relative to image base. */
1615 long base
; /* Ordinal base. */
1616 unsigned long num_functions
;/* Number in the export address table. */
1617 unsigned long num_names
; /* Number in the name pointer table. */
1618 bfd_vma eat_addr
; /* RVA to the export address table. */
1619 bfd_vma npt_addr
; /* RVA to the Export Name Pointer Table. */
1620 bfd_vma ot_addr
; /* RVA to the Ordinal Table. */
1623 pe_data_type
*pe
= pe_data (abfd
);
1624 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1628 addr
= extra
->DataDirectory
[PE_EXPORT_TABLE
].VirtualAddress
;
1630 if (addr
== 0 && extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
== 0)
1632 /* Maybe the extra header isn't there. Look for the section. */
1633 section
= bfd_get_section_by_name (abfd
, ".edata");
1634 if (section
== NULL
)
1637 addr
= section
->vma
;
1639 datasize
= section
->size
;
1645 addr
+= extra
->ImageBase
;
1647 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1648 if (addr
>= section
->vma
&& addr
< section
->vma
+ section
->size
)
1651 if (section
== NULL
)
1654 _("\nThere is an export table, but the section containing it could not be found\n"));
1657 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1660 _("\nThere is an export table in %s, but that section has no contents\n"),
1665 dataoff
= addr
- section
->vma
;
1666 datasize
= extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
;
1667 if (dataoff
> section
->size
1668 || datasize
> section
->size
- dataoff
)
1671 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1677 /* PR 17512: Handle corrupt PE binaries. */
1681 /* xgettext:c-format */
1682 _("\nThere is an export table in %s, but it is too small (%d)\n"),
1683 section
->name
, (int) datasize
);
1687 /* xgettext:c-format */
1688 fprintf (file
, _("\nThere is an export table in %s at 0x%lx\n"),
1689 section
->name
, (unsigned long) addr
);
1691 data
= (bfd_byte
*) bfd_malloc (datasize
);
1695 if (! bfd_get_section_contents (abfd
, section
, data
,
1696 (file_ptr
) dataoff
, datasize
))
1699 /* Go get Export Directory Table. */
1700 edt
.export_flags
= bfd_get_32 (abfd
, data
+ 0);
1701 edt
.time_stamp
= bfd_get_32 (abfd
, data
+ 4);
1702 edt
.major_ver
= bfd_get_16 (abfd
, data
+ 8);
1703 edt
.minor_ver
= bfd_get_16 (abfd
, data
+ 10);
1704 edt
.name
= bfd_get_32 (abfd
, data
+ 12);
1705 edt
.base
= bfd_get_32 (abfd
, data
+ 16);
1706 edt
.num_functions
= bfd_get_32 (abfd
, data
+ 20);
1707 edt
.num_names
= bfd_get_32 (abfd
, data
+ 24);
1708 edt
.eat_addr
= bfd_get_32 (abfd
, data
+ 28);
1709 edt
.npt_addr
= bfd_get_32 (abfd
, data
+ 32);
1710 edt
.ot_addr
= bfd_get_32 (abfd
, data
+ 36);
1712 adj
= section
->vma
- extra
->ImageBase
+ dataoff
;
1714 /* Dump the EDT first. */
1716 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1720 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt
.export_flags
);
1723 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt
.time_stamp
);
1726 /* xgettext:c-format */
1727 _("Major/Minor \t\t\t%d/%d\n"), edt
.major_ver
, edt
.minor_ver
);
1730 _("Name \t\t\t\t"));
1731 bfd_fprintf_vma (abfd
, file
, edt
.name
);
1733 if ((edt
.name
>= adj
) && (edt
.name
< adj
+ datasize
))
1734 fprintf (file
, " %.*s\n",
1735 (int) (datasize
- (edt
.name
- adj
)),
1736 data
+ edt
.name
- adj
);
1738 fprintf (file
, "(outside .edata section)\n");
1741 _("Ordinal Base \t\t\t%ld\n"), edt
.base
);
1747 _("\tExport Address Table \t\t%08lx\n"),
1751 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt
.num_names
);
1754 _("Table Addresses\n"));
1757 _("\tExport Address Table \t\t"));
1758 bfd_fprintf_vma (abfd
, file
, edt
.eat_addr
);
1759 fprintf (file
, "\n");
1762 _("\tName Pointer Table \t\t"));
1763 bfd_fprintf_vma (abfd
, file
, edt
.npt_addr
);
1764 fprintf (file
, "\n");
1767 _("\tOrdinal Table \t\t\t"));
1768 bfd_fprintf_vma (abfd
, file
, edt
.ot_addr
);
1769 fprintf (file
, "\n");
1771 /* The next table to find is the Export Address Table. It's basically
1772 a list of pointers that either locate a function in this dll, or
1773 forward the call to another dll. Something like:
1778 } export_address_table_entry; */
1781 _("\nExport Address Table -- Ordinal Base %ld\n"),
1784 /* PR 17512: Handle corrupt PE binaries. */
1785 /* PR 17512 file: 140-165018-0.004. */
1786 if (edt
.eat_addr
- adj
>= datasize
1787 /* PR 17512: file: 092b1829 */
1788 || (edt
.num_functions
+ 1) * 4 < edt
.num_functions
1789 || edt
.eat_addr
- adj
+ (edt
.num_functions
+ 1) * 4 > datasize
)
1790 fprintf (file
, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1791 (long) edt
.eat_addr
,
1792 (long) edt
.num_functions
);
1793 else for (i
= 0; i
< edt
.num_functions
; ++i
)
1795 bfd_vma eat_member
= bfd_get_32 (abfd
,
1796 data
+ edt
.eat_addr
+ (i
* 4) - adj
);
1797 if (eat_member
== 0)
1800 if (eat_member
- adj
<= datasize
)
1802 /* This rva is to a name (forwarding function) in our section. */
1803 /* Should locate a function descriptor. */
1805 "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1807 (long) (i
+ edt
.base
),
1808 (unsigned long) eat_member
,
1810 (int)(datasize
- (eat_member
- adj
)),
1811 data
+ eat_member
- adj
);
1815 /* Should locate a function descriptor in the reldata section. */
1817 "\t[%4ld] +base[%4ld] %04lx %s\n",
1819 (long) (i
+ edt
.base
),
1820 (unsigned long) eat_member
,
1825 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1826 /* Dump them in parallel for clarity. */
1828 _("\n[Ordinal/Name Pointer] Table\n"));
1830 /* PR 17512: Handle corrupt PE binaries. */
1831 if (edt
.npt_addr
+ (edt
.num_names
* 4) - adj
>= datasize
1832 /* PR 17512: file: bb68816e. */
1833 || edt
.num_names
* 4 < edt
.num_names
1834 || (data
+ edt
.npt_addr
- adj
) < data
)
1835 /* xgettext:c-format */
1836 fprintf (file
, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1837 (long) edt
.npt_addr
,
1838 (long) edt
.num_names
);
1839 /* PR 17512: file: 140-147171-0.004. */
1840 else if (edt
.ot_addr
+ (edt
.num_names
* 2) - adj
>= datasize
1841 || data
+ edt
.ot_addr
- adj
< data
)
1842 /* xgettext:c-format */
1843 fprintf (file
, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1845 (long) edt
.num_names
);
1846 else for (i
= 0; i
< edt
.num_names
; ++i
)
1851 ord
= bfd_get_16 (abfd
, data
+ edt
.ot_addr
+ (i
* 2) - adj
);
1852 name_ptr
= bfd_get_32 (abfd
, data
+ edt
.npt_addr
+ (i
* 4) - adj
);
1854 if ((name_ptr
- adj
) >= datasize
)
1856 /* xgettext:c-format */
1857 fprintf (file
, _("\t[%4ld] <corrupt offset: %lx>\n"),
1858 (long) ord
, (long) name_ptr
);
1862 char * name
= (char *) data
+ name_ptr
- adj
;
1864 fprintf (file
, "\t[%4ld] %.*s\n", (long) ord
,
1865 (int)((char *)(data
+ datasize
) - name
), name
);
1874 /* This really is architecture dependent. On IA-64, a .pdata entry
1875 consists of three dwords containing relative virtual addresses that
1876 specify the start and end address of the code range the entry
1877 covers and the address of the corresponding unwind info data.
1879 On ARM and SH-4, a compressed PDATA structure is used :
1880 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1881 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1882 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1884 This is the version for uncompressed data. */
1887 pe_print_pdata (bfd
* abfd
, void * vfile
)
1889 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1890 # define PDATA_ROW_SIZE (3 * 8)
1892 # define PDATA_ROW_SIZE (5 * 4)
1894 FILE *file
= (FILE *) vfile
;
1896 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1897 bfd_size_type datasize
= 0;
1899 bfd_size_type start
, stop
;
1900 int onaline
= PDATA_ROW_SIZE
;
1903 || coff_section_data (abfd
, section
) == NULL
1904 || pei_section_data (abfd
, section
) == NULL
)
1907 stop
= pei_section_data (abfd
, section
)->virt_size
;
1908 if ((stop
% onaline
) != 0)
1910 /* xgettext:c-format */
1911 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
1912 (long) stop
, onaline
);
1915 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1916 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1918 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1921 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1922 \t\tAddress Address Handler Data Address Mask\n"));
1925 datasize
= section
->size
;
1929 /* PR 17512: file: 002-193900-0.004. */
1930 if (datasize
< stop
)
1932 /* xgettext:c-format */
1933 fprintf (file
, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"),
1934 (long) stop
, (long) datasize
);
1938 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
1946 for (i
= start
; i
< stop
; i
+= onaline
)
1952 bfd_vma prolog_end_addr
;
1953 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1957 if (i
+ PDATA_ROW_SIZE
> stop
)
1960 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
1961 end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
1962 eh_handler
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 8);
1963 eh_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 12);
1964 prolog_end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 16);
1966 if (begin_addr
== 0 && end_addr
== 0 && eh_handler
== 0
1967 && eh_data
== 0 && prolog_end_addr
== 0)
1968 /* We are probably into the padding of the section now. */
1971 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1972 em_data
= ((eh_handler
& 0x1) << 2) | (prolog_end_addr
& 0x3);
1974 eh_handler
&= ~(bfd_vma
) 0x3;
1975 prolog_end_addr
&= ~(bfd_vma
) 0x3;
1978 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
1979 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
1980 bfd_fprintf_vma (abfd
, file
, end_addr
); fputc (' ', file
);
1981 bfd_fprintf_vma (abfd
, file
, eh_handler
);
1982 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1984 bfd_fprintf_vma (abfd
, file
, eh_data
); fputc (' ', file
);
1985 bfd_fprintf_vma (abfd
, file
, prolog_end_addr
);
1986 fprintf (file
, " %x", em_data
);
1989 #ifdef POWERPC_LE_PE
1990 if (eh_handler
== 0 && eh_data
!= 0)
1992 /* Special bits here, although the meaning may be a little
1993 mysterious. The only one I know for sure is 0x03
1996 0x01 Register Save Millicode
1997 0x02 Register Restore Millicode
1998 0x03 Glue Code Sequence. */
2002 fprintf (file
, _(" Register save millicode"));
2005 fprintf (file
, _(" Register restore millicode"));
2008 fprintf (file
, _(" Glue code sequence"));
2015 fprintf (file
, "\n");
2021 #undef PDATA_ROW_SIZE
2024 typedef struct sym_cache
2031 slurp_symtab (bfd
*abfd
, sym_cache
*psc
)
2033 asymbol
** sy
= NULL
;
2036 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
2042 storage
= bfd_get_symtab_upper_bound (abfd
);
2047 sy
= (asymbol
**) bfd_malloc (storage
);
2052 psc
->symcount
= bfd_canonicalize_symtab (abfd
, sy
);
2053 if (psc
->symcount
< 0)
2059 my_symbol_for_address (bfd
*abfd
, bfd_vma func
, sym_cache
*psc
)
2064 psc
->syms
= slurp_symtab (abfd
, psc
);
2066 for (i
= 0; i
< psc
->symcount
; i
++)
2068 if (psc
->syms
[i
]->section
->vma
+ psc
->syms
[i
]->value
== func
)
2069 return psc
->syms
[i
]->name
;
2076 cleanup_syms (sym_cache
*psc
)
2083 /* This is the version for "compressed" pdata. */
2086 _bfd_XX_print_ce_compressed_pdata (bfd
* abfd
, void * vfile
)
2088 # define PDATA_ROW_SIZE (2 * 4)
2089 FILE *file
= (FILE *) vfile
;
2090 bfd_byte
*data
= NULL
;
2091 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
2092 bfd_size_type datasize
= 0;
2094 bfd_size_type start
, stop
;
2095 int onaline
= PDATA_ROW_SIZE
;
2096 struct sym_cache cache
= {0, 0} ;
2099 || coff_section_data (abfd
, section
) == NULL
2100 || pei_section_data (abfd
, section
) == NULL
)
2103 stop
= pei_section_data (abfd
, section
)->virt_size
;
2104 if ((stop
% onaline
) != 0)
2106 /* xgettext:c-format */
2107 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
2108 (long) stop
, onaline
);
2111 _("\nThe Function Table (interpreted .pdata section contents)\n"));
2114 vma:\t\tBegin Prolog Function Flags Exception EH\n\
2115 \t\tAddress Length Length 32b exc Handler Data\n"));
2117 datasize
= section
->size
;
2121 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
))
2243 end
= data
+ section
->size
;
2244 while (p
+ 8 <= end
)
2247 bfd_vma virtual_address
;
2248 unsigned long number
, size
;
2249 bfd_byte
*chunk_end
;
2251 /* The .reloc section is a sequence of blocks, with a header consisting
2252 of two 32 bit quantities, followed by a number of 16 bit entries. */
2253 virtual_address
= bfd_get_32 (abfd
, p
);
2254 size
= bfd_get_32 (abfd
, p
+ 4);
2256 number
= (size
- 8) / 2;
2262 /* xgettext:c-format */
2263 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2264 (unsigned long) virtual_address
, size
, size
, number
);
2266 chunk_end
= p
- 8 + size
;
2267 if (chunk_end
> end
)
2270 while (p
+ 2 <= chunk_end
)
2272 unsigned short e
= bfd_get_16 (abfd
, p
);
2273 unsigned int t
= (e
& 0xF000) >> 12;
2274 int off
= e
& 0x0FFF;
2276 if (t
>= sizeof (tbl
) / sizeof (tbl
[0]))
2277 t
= (sizeof (tbl
) / sizeof (tbl
[0])) - 1;
2280 /* xgettext:c-format */
2281 _("\treloc %4d offset %4x [%4lx] %s"),
2282 j
, off
, (unsigned long) (off
+ virtual_address
), tbl
[t
]);
2287 /* HIGHADJ takes an argument, - the next record *is* the
2288 low 16 bits of addend. */
2289 if (t
== IMAGE_REL_BASED_HIGHADJ
&& p
+ 2 <= chunk_end
)
2291 fprintf (file
, " (%4x)", (unsigned int) bfd_get_16 (abfd
, p
));
2296 fprintf (file
, "\n");
2305 /* A data structure describing the regions of a .rsrc section.
2306 Some fields are filled in as the section is parsed. */
2308 typedef struct rsrc_regions
2310 bfd_byte
* section_start
;
2311 bfd_byte
* section_end
;
2312 bfd_byte
* strings_start
;
2313 bfd_byte
* resource_start
;
2317 rsrc_print_resource_directory (FILE * , bfd
*, unsigned int, bfd_byte
*,
2318 rsrc_regions
*, bfd_vma
);
2320 /* Print the resource entry at DATA, with the text indented by INDENT.
2321 Recusively calls rsrc_print_resource_directory to print the contents
2322 of directory entries.
2323 Returns the address of the end of the data associated with the entry
2324 or section_end + 1 upon failure. */
2327 rsrc_print_resource_entries (FILE * file
,
2329 unsigned int indent
,
2330 bfd_boolean is_name
,
2332 rsrc_regions
* regions
,
2335 unsigned long entry
, addr
, size
;
2338 if (data
+ 8 >= regions
->section_end
)
2339 return regions
->section_end
+ 1;
2341 /* xgettext:c-format */
2342 fprintf (file
, _("%03x %*.s Entry: "), (int)(data
- regions
->section_start
), indent
, " ");
2344 entry
= (unsigned long) bfd_get_32 (abfd
, data
);
2349 /* Note - the documentation says that this field is an RVA value
2350 but windres appears to produce a section relative offset with
2351 the top bit set. Support both styles for now. */
2352 if (HighBitSet (entry
))
2353 name
= regions
->section_start
+ WithoutHighBit (entry
);
2355 name
= regions
->section_start
+ entry
- rva_bias
;
2357 if (name
+ 2 < regions
->section_end
&& name
> regions
->section_start
)
2361 if (regions
->strings_start
== NULL
)
2362 regions
->strings_start
= name
;
2364 len
= bfd_get_16 (abfd
, name
);
2366 fprintf (file
, _("name: [val: %08lx len %d]: "), entry
, len
);
2368 if (name
+ 2 + len
* 2 < regions
->section_end
)
2370 /* This strange loop is to cope with multibyte characters. */
2377 /* Avoid printing control characters. */
2378 if (c
> 0 && c
< 32)
2379 fprintf (file
, "^%c", c
+ 64);
2381 fprintf (file
, "%.1s", name
);
2386 fprintf (file
, _("<corrupt string length: %#x>\n"), len
);
2387 /* PR binutils/17512: Do not try to continue decoding a
2388 corrupted resource section. It is likely to end up with
2389 reams of extraneous output. FIXME: We could probably
2390 continue if we disable the printing of strings... */
2391 return regions
->section_end
+ 1;
2396 fprintf (file
, _("<corrupt string offset: %#lx>\n"), entry
);
2397 return regions
->section_end
+ 1;
2401 fprintf (file
, _("ID: %#08lx"), entry
);
2403 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
2404 fprintf (file
, _(", Value: %#08lx\n"), entry
);
2406 if (HighBitSet (entry
))
2408 data
= regions
->section_start
+ WithoutHighBit (entry
);
2409 if (data
<= regions
->section_start
|| data
> regions
->section_end
)
2410 return regions
->section_end
+ 1;
2412 /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2413 in the resource table. We need some way to detect this. */
2414 return rsrc_print_resource_directory (file
, abfd
, indent
+ 1, data
,
2418 leaf
= regions
->section_start
+ entry
;
2420 if (leaf
+ 16 >= regions
->section_end
2421 /* PR 17512: file: 055dff7e. */
2422 || leaf
< regions
->section_start
)
2423 return regions
->section_end
+ 1;
2425 /* xgettext:c-format */
2426 fprintf (file
, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2427 (int) (entry
), indent
, " ",
2428 addr
= (long) bfd_get_32 (abfd
, leaf
),
2429 size
= (long) bfd_get_32 (abfd
, leaf
+ 4),
2430 (int) bfd_get_32 (abfd
, leaf
+ 8));
2432 /* Check that the reserved entry is 0. */
2433 if (bfd_get_32 (abfd
, leaf
+ 12) != 0
2434 /* And that the data address/size is valid too. */
2435 || (regions
->section_start
+ (addr
- rva_bias
) + size
> regions
->section_end
))
2436 return regions
->section_end
+ 1;
2438 if (regions
->resource_start
== NULL
)
2439 regions
->resource_start
= regions
->section_start
+ (addr
- rva_bias
);
2441 return regions
->section_start
+ (addr
- rva_bias
) + size
;
2444 #define max(a,b) ((a) > (b) ? (a) : (b))
2445 #define min(a,b) ((a) < (b) ? (a) : (b))
2448 rsrc_print_resource_directory (FILE * file
,
2450 unsigned int indent
,
2452 rsrc_regions
* regions
,
2455 unsigned int num_names
, num_ids
;
2456 bfd_byte
* highest_data
= data
;
2458 if (data
+ 16 >= regions
->section_end
)
2459 return regions
->section_end
+ 1;
2461 fprintf (file
, "%03x %*.s ", (int)(data
- regions
->section_start
), indent
, " ");
2464 case 0: fprintf (file
, "Type"); break;
2465 case 2: fprintf (file
, "Name"); break;
2466 case 4: fprintf (file
, "Language"); break;
2468 fprintf (file
, _("<unknown directory type: %d>\n"), indent
);
2469 /* FIXME: For now we end the printing here. If in the
2470 future more directory types are added to the RSRC spec
2471 then we will need to change this. */
2472 return regions
->section_end
+ 1;
2475 /* xgettext:c-format */
2476 fprintf (file
, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2477 (int) bfd_get_32 (abfd
, data
),
2478 (long) bfd_get_32 (abfd
, data
+ 4),
2479 (int) bfd_get_16 (abfd
, data
+ 8),
2480 (int) bfd_get_16 (abfd
, data
+ 10),
2481 num_names
= (int) bfd_get_16 (abfd
, data
+ 12),
2482 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14));
2485 while (num_names
--)
2487 bfd_byte
* entry_end
;
2489 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, TRUE
,
2490 data
, regions
, rva_bias
);
2492 highest_data
= max (highest_data
, entry_end
);
2493 if (entry_end
>= regions
->section_end
)
2499 bfd_byte
* entry_end
;
2501 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, FALSE
,
2502 data
, regions
, rva_bias
);
2504 highest_data
= max (highest_data
, entry_end
);
2505 if (entry_end
>= regions
->section_end
)
2509 return max (highest_data
, data
);
2512 /* Display the contents of a .rsrc section. We do not try to
2513 reproduce the resources, windres does that. Instead we dump
2514 the tables in a human readable format. */
2517 rsrc_print_section (bfd
* abfd
, void * vfile
)
2521 FILE * file
= (FILE *) vfile
;
2522 bfd_size_type datasize
;
2525 rsrc_regions regions
;
2527 pe
= pe_data (abfd
);
2531 section
= bfd_get_section_by_name (abfd
, ".rsrc");
2532 if (section
== NULL
)
2534 if (!(section
->flags
& SEC_HAS_CONTENTS
))
2537 datasize
= section
->size
;
2541 rva_bias
= section
->vma
- pe
->pe_opthdr
.ImageBase
;
2543 if (! bfd_malloc_and_get_section (abfd
, section
, & data
))
2549 regions
.section_start
= data
;
2550 regions
.section_end
= data
+ datasize
;
2551 regions
.strings_start
= NULL
;
2552 regions
.resource_start
= NULL
;
2555 fprintf (file
, "\nThe .rsrc Resource Directory section:\n");
2557 while (data
< regions
.section_end
)
2559 bfd_byte
* p
= data
;
2561 data
= rsrc_print_resource_directory (file
, abfd
, 0, data
, & regions
, rva_bias
);
2563 if (data
== regions
.section_end
+ 1)
2564 fprintf (file
, _("Corrupt .rsrc section detected!\n"));
2567 /* Align data before continuing. */
2568 int align
= (1 << section
->alignment_power
) - 1;
2570 data
= (bfd_byte
*) (((ptrdiff_t) (data
+ align
)) & ~ align
);
2571 rva_bias
+= data
- p
;
2573 /* For reasons that are unclear .rsrc sections are sometimes created
2574 aligned to a 1^3 boundary even when their alignment is set at
2575 1^2. Catch that case here before we issue a spurious warning
2577 if (data
== (regions
.section_end
- 4))
2578 data
= regions
.section_end
;
2579 else if (data
< regions
.section_end
)
2581 /* If the extra data is all zeros then do not complain.
2582 This is just padding so that the section meets the
2583 page size requirements. */
2584 while (++ data
< regions
.section_end
)
2587 if (data
< regions
.section_end
)
2588 fprintf (file
, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2593 if (regions
.strings_start
!= NULL
)
2594 fprintf (file
, _(" String table starts at offset: %#03x\n"),
2595 (int) (regions
.strings_start
- regions
.section_start
));
2596 if (regions
.resource_start
!= NULL
)
2597 fprintf (file
, _(" Resources start at offset: %#03x\n"),
2598 (int) (regions
.resource_start
- regions
.section_start
));
2600 free (regions
.section_start
);
2604 #define IMAGE_NUMBEROF_DEBUG_TYPES 17
2606 static char * debug_type_names
[IMAGE_NUMBEROF_DEBUG_TYPES
] =
2628 pe_print_debugdata (bfd
* abfd
, void * vfile
)
2630 FILE *file
= (FILE *) vfile
;
2631 pe_data_type
*pe
= pe_data (abfd
);
2632 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2635 bfd_size_type dataoff
;
2638 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2639 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2644 addr
+= extra
->ImageBase
;
2645 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2647 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2651 if (section
== NULL
)
2654 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2657 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
2660 _("\nThere is a debug directory in %s, but that section has no contents\n"),
2664 else if (section
->size
< size
)
2667 _("\nError: section %s contains the debug data starting address but it is too small\n"),
2672 fprintf (file
, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2673 section
->name
, (unsigned long) addr
);
2675 dataoff
= addr
- section
->vma
;
2677 if (size
> (section
->size
- dataoff
))
2679 fprintf (file
, _("The debug data size field in the data directory is too big for the section"));
2684 _("Type Size Rva Offset\n"));
2686 /* Read the whole section. */
2687 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2693 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2695 const char *type_name
;
2696 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2697 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2698 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2700 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2702 if ((idd
.Type
) >= IMAGE_NUMBEROF_DEBUG_TYPES
)
2703 type_name
= debug_type_names
[0];
2705 type_name
= debug_type_names
[idd
.Type
];
2707 fprintf (file
, " %2ld %14s %08lx %08lx %08lx\n",
2708 idd
.Type
, type_name
, idd
.SizeOfData
,
2709 idd
.AddressOfRawData
, idd
.PointerToRawData
);
2711 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_CODEVIEW
)
2713 char signature
[CV_INFO_SIGNATURE_LENGTH
* 2 + 1];
2714 /* PR 17512: file: 065-29434-0.001:0.1
2715 We need to use a 32-bit aligned buffer
2716 to safely read in a codeview record. */
2717 char buffer
[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO
);
2719 CODEVIEW_INFO
*cvinfo
= (CODEVIEW_INFO
*) buffer
;
2721 /* The debug entry doesn't have to have to be in a section,
2722 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2723 if (!_bfd_XXi_slurp_codeview_record (abfd
, (file_ptr
) idd
.PointerToRawData
,
2724 idd
.SizeOfData
, cvinfo
))
2727 for (j
= 0; j
< cvinfo
->SignatureLength
; j
++)
2728 sprintf (&signature
[j
*2], "%02x", cvinfo
->Signature
[j
] & 0xff);
2730 /* xgettext:c-format */
2731 fprintf (file
, _("(format %c%c%c%c signature %s age %ld)\n"),
2732 buffer
[0], buffer
[1], buffer
[2], buffer
[3],
2733 signature
, cvinfo
->Age
);
2739 if (size
% sizeof (struct external_IMAGE_DEBUG_DIRECTORY
) != 0)
2741 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2747 pe_is_repro (bfd
* abfd
)
2749 pe_data_type
*pe
= pe_data (abfd
);
2750 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2753 bfd_size_type dataoff
;
2755 bfd_boolean res
= FALSE
;
2757 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2758 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2763 addr
+= extra
->ImageBase
;
2764 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2766 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2770 if ((section
== NULL
)
2771 || (!(section
->flags
& SEC_HAS_CONTENTS
))
2772 || (section
->size
< size
))
2777 dataoff
= addr
- section
->vma
;
2779 if (size
> (section
->size
- dataoff
))
2784 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2790 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2792 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2793 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2794 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2796 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2798 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_REPRO
)
2810 /* Print out the program headers. */
2813 _bfd_XX_print_private_bfd_data_common (bfd
* abfd
, void * vfile
)
2815 FILE *file
= (FILE *) vfile
;
2817 pe_data_type
*pe
= pe_data (abfd
);
2818 struct internal_extra_pe_aouthdr
*i
= &pe
->pe_opthdr
;
2819 const char *subsystem_name
= NULL
;
2822 /* The MS dumpbin program reportedly ands with 0xff0f before
2823 printing the characteristics field. Not sure why. No reason to
2825 fprintf (file
, _("\nCharacteristics 0x%x\n"), pe
->real_flags
);
2827 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2828 PF (IMAGE_FILE_RELOCS_STRIPPED
, "relocations stripped");
2829 PF (IMAGE_FILE_EXECUTABLE_IMAGE
, "executable");
2830 PF (IMAGE_FILE_LINE_NUMS_STRIPPED
, "line numbers stripped");
2831 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED
, "symbols stripped");
2832 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE
, "large address aware");
2833 PF (IMAGE_FILE_BYTES_REVERSED_LO
, "little endian");
2834 PF (IMAGE_FILE_32BIT_MACHINE
, "32 bit words");
2835 PF (IMAGE_FILE_DEBUG_STRIPPED
, "debugging information removed");
2836 PF (IMAGE_FILE_SYSTEM
, "system file");
2837 PF (IMAGE_FILE_DLL
, "DLL");
2838 PF (IMAGE_FILE_BYTES_REVERSED_HI
, "big endian");
2842 If a PE_IMAGE_DEBUG_TYPE_REPRO entry is present in the debug directory, the
2843 timestamp is to be interpreted as the hash of a reproducible build.
2845 if (pe_is_repro (abfd
))
2847 fprintf (file
, "\nTime/Date\t\t%08lx", pe
->coff
.timestamp
);
2848 fprintf (file
, "\t(This is a reproducible build file hash, not a timestamp)\n");
2852 /* ctime implies '\n'. */
2853 time_t t
= pe
->coff
.timestamp
;
2854 fprintf (file
, "\nTime/Date\t\t%s", ctime (&t
));
2857 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2858 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2860 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2861 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2863 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2864 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2869 case IMAGE_NT_OPTIONAL_HDR_MAGIC
:
2872 case IMAGE_NT_OPTIONAL_HDR64_MAGIC
:
2875 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC
:
2882 fprintf (file
, "Magic\t\t\t%04x", i
->Magic
);
2884 fprintf (file
, "\t(%s)",name
);
2885 fprintf (file
, "\nMajorLinkerVersion\t%d\n", i
->MajorLinkerVersion
);
2886 fprintf (file
, "MinorLinkerVersion\t%d\n", i
->MinorLinkerVersion
);
2887 fprintf (file
, "SizeOfCode\t\t");
2888 bfd_fprintf_vma (abfd
, file
, i
->SizeOfCode
);
2889 fprintf (file
, "\nSizeOfInitializedData\t");
2890 bfd_fprintf_vma (abfd
, file
, i
->SizeOfInitializedData
);
2891 fprintf (file
, "\nSizeOfUninitializedData\t");
2892 bfd_fprintf_vma (abfd
, file
, i
->SizeOfUninitializedData
);
2893 fprintf (file
, "\nAddressOfEntryPoint\t");
2894 bfd_fprintf_vma (abfd
, file
, i
->AddressOfEntryPoint
);
2895 fprintf (file
, "\nBaseOfCode\t\t");
2896 bfd_fprintf_vma (abfd
, file
, i
->BaseOfCode
);
2897 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2898 /* PE32+ does not have BaseOfData member! */
2899 fprintf (file
, "\nBaseOfData\t\t");
2900 bfd_fprintf_vma (abfd
, file
, i
->BaseOfData
);
2903 fprintf (file
, "\nImageBase\t\t");
2904 bfd_fprintf_vma (abfd
, file
, i
->ImageBase
);
2905 fprintf (file
, "\nSectionAlignment\t%08x\n", i
->SectionAlignment
);
2906 fprintf (file
, "FileAlignment\t\t%08x\n", i
->FileAlignment
);
2907 fprintf (file
, "MajorOSystemVersion\t%d\n", i
->MajorOperatingSystemVersion
);
2908 fprintf (file
, "MinorOSystemVersion\t%d\n", i
->MinorOperatingSystemVersion
);
2909 fprintf (file
, "MajorImageVersion\t%d\n", i
->MajorImageVersion
);
2910 fprintf (file
, "MinorImageVersion\t%d\n", i
->MinorImageVersion
);
2911 fprintf (file
, "MajorSubsystemVersion\t%d\n", i
->MajorSubsystemVersion
);
2912 fprintf (file
, "MinorSubsystemVersion\t%d\n", i
->MinorSubsystemVersion
);
2913 fprintf (file
, "Win32Version\t\t%08x\n", i
->Reserved1
);
2914 fprintf (file
, "SizeOfImage\t\t%08x\n", i
->SizeOfImage
);
2915 fprintf (file
, "SizeOfHeaders\t\t%08x\n", i
->SizeOfHeaders
);
2916 fprintf (file
, "CheckSum\t\t%08x\n", i
->CheckSum
);
2918 switch (i
->Subsystem
)
2920 case IMAGE_SUBSYSTEM_UNKNOWN
:
2921 subsystem_name
= "unspecified";
2923 case IMAGE_SUBSYSTEM_NATIVE
:
2924 subsystem_name
= "NT native";
2926 case IMAGE_SUBSYSTEM_WINDOWS_GUI
:
2927 subsystem_name
= "Windows GUI";
2929 case IMAGE_SUBSYSTEM_WINDOWS_CUI
:
2930 subsystem_name
= "Windows CUI";
2932 case IMAGE_SUBSYSTEM_POSIX_CUI
:
2933 subsystem_name
= "POSIX CUI";
2935 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI
:
2936 subsystem_name
= "Wince CUI";
2938 /* These are from UEFI Platform Initialization Specification 1.1. */
2939 case IMAGE_SUBSYSTEM_EFI_APPLICATION
:
2940 subsystem_name
= "EFI application";
2942 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
:
2943 subsystem_name
= "EFI boot service driver";
2945 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
:
2946 subsystem_name
= "EFI runtime driver";
2948 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER
:
2949 subsystem_name
= "SAL runtime driver";
2951 /* This is from revision 8.0 of the MS PE/COFF spec */
2952 case IMAGE_SUBSYSTEM_XBOX
:
2953 subsystem_name
= "XBOX";
2955 /* Added default case for clarity - subsystem_name is NULL anyway. */
2957 subsystem_name
= NULL
;
2960 fprintf (file
, "Subsystem\t\t%08x", i
->Subsystem
);
2962 fprintf (file
, "\t(%s)", subsystem_name
);
2963 fprintf (file
, "\nDllCharacteristics\t%08x\n", i
->DllCharacteristics
);
2964 fprintf (file
, "SizeOfStackReserve\t");
2965 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackReserve
);
2966 fprintf (file
, "\nSizeOfStackCommit\t");
2967 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackCommit
);
2968 fprintf (file
, "\nSizeOfHeapReserve\t");
2969 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapReserve
);
2970 fprintf (file
, "\nSizeOfHeapCommit\t");
2971 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapCommit
);
2972 fprintf (file
, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i
->LoaderFlags
);
2973 fprintf (file
, "NumberOfRvaAndSizes\t%08lx\n",
2974 (unsigned long) i
->NumberOfRvaAndSizes
);
2976 fprintf (file
, "\nThe Data Directory\n");
2977 for (j
= 0; j
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; j
++)
2979 fprintf (file
, "Entry %1x ", j
);
2980 bfd_fprintf_vma (abfd
, file
, i
->DataDirectory
[j
].VirtualAddress
);
2981 fprintf (file
, " %08lx ", (unsigned long) i
->DataDirectory
[j
].Size
);
2982 fprintf (file
, "%s\n", dir_names
[j
]);
2985 pe_print_idata (abfd
, vfile
);
2986 pe_print_edata (abfd
, vfile
);
2987 if (bfd_coff_have_print_pdata (abfd
))
2988 bfd_coff_print_pdata (abfd
, vfile
);
2990 pe_print_pdata (abfd
, vfile
);
2991 pe_print_reloc (abfd
, vfile
);
2992 pe_print_debugdata (abfd
, file
);
2994 rsrc_print_section (abfd
, vfile
);
3000 is_vma_in_section (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sect
, void *obj
)
3002 bfd_vma addr
= * (bfd_vma
*) obj
;
3003 return (addr
>= sect
->vma
) && (addr
< (sect
->vma
+ sect
->size
));
3007 find_section_by_vma (bfd
*abfd
, bfd_vma addr
)
3009 return bfd_sections_find_if (abfd
, is_vma_in_section
, (void *) & addr
);
3012 /* Copy any private info we understand from the input bfd
3013 to the output bfd. */
3016 _bfd_XX_bfd_copy_private_bfd_data_common (bfd
* ibfd
, bfd
* obfd
)
3018 pe_data_type
*ipe
, *ope
;
3020 /* One day we may try to grok other private data. */
3021 if (ibfd
->xvec
->flavour
!= bfd_target_coff_flavour
3022 || obfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
3025 ipe
= pe_data (ibfd
);
3026 ope
= pe_data (obfd
);
3028 /* pe_opthdr is copied in copy_object. */
3029 ope
->dll
= ipe
->dll
;
3031 /* Don't copy input subsystem if output is different from input. */
3032 if (obfd
->xvec
!= ibfd
->xvec
)
3033 ope
->pe_opthdr
.Subsystem
= IMAGE_SUBSYSTEM_UNKNOWN
;
3035 /* For strip: if we removed .reloc, we'll make a real mess of things
3036 if we don't remove this entry as well. */
3037 if (! pe_data (obfd
)->has_reloc_section
)
3039 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].VirtualAddress
= 0;
3040 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].Size
= 0;
3043 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
3044 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
3046 if (! pe_data (ibfd
)->has_reloc_section
3047 && ! (pe_data (ibfd
)->real_flags
& IMAGE_FILE_RELOCS_STRIPPED
))
3048 pe_data (obfd
)->dont_strip_reloc
= 1;
3050 memcpy (ope
->dos_message
, ipe
->dos_message
, sizeof (ope
->dos_message
));
3052 /* The file offsets contained in the debug directory need rewriting. */
3053 if (ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
!= 0)
3055 bfd_vma addr
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
3056 + ope
->pe_opthdr
.ImageBase
;
3057 asection
*section
= find_section_by_vma (obfd
, addr
);
3060 if (section
&& bfd_malloc_and_get_section (obfd
, section
, &data
))
3063 struct external_IMAGE_DEBUG_DIRECTORY
*dd
=
3064 (struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ (addr
- section
->vma
));
3066 /* PR 17512: file: 0f15796a. */
3067 if ((unsigned long) ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
3068 > section
->size
- (addr
- section
->vma
))
3070 /* xgettext:c-format */
3072 (_("%pB: Data Directory size (%lx) "
3073 "exceeds space left in section (%" PRIx64
")"),
3074 obfd
, ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
,
3075 (uint64_t) (section
->size
- (addr
- section
->vma
)));
3080 for (i
= 0; i
< ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
3081 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
3083 asection
*ddsection
;
3084 struct external_IMAGE_DEBUG_DIRECTORY
*edd
= &(dd
[i
]);
3085 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
3087 _bfd_XXi_swap_debugdir_in (obfd
, edd
, &idd
);
3089 if (idd
.AddressOfRawData
== 0)
3090 continue; /* RVA 0 means only offset is valid, not handled yet. */
3092 ddsection
= find_section_by_vma (obfd
, idd
.AddressOfRawData
+ ope
->pe_opthdr
.ImageBase
);
3094 continue; /* Not in a section! */
3096 idd
.PointerToRawData
= ddsection
->filepos
+ (idd
.AddressOfRawData
3097 + ope
->pe_opthdr
.ImageBase
) - ddsection
->vma
;
3099 _bfd_XXi_swap_debugdir_out (obfd
, &idd
, edd
);
3102 if (!bfd_set_section_contents (obfd
, section
, data
, 0, section
->size
))
3104 _bfd_error_handler (_("failed to update file offsets in debug directory"));
3112 _bfd_error_handler (_("%pB: failed to read debug data section"), obfd
);
3120 /* Copy private section data. */
3123 _bfd_XX_bfd_copy_private_section_data (bfd
*ibfd
,
3128 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
3129 || bfd_get_flavour (obfd
) != bfd_target_coff_flavour
)
3132 if (coff_section_data (ibfd
, isec
) != NULL
3133 && pei_section_data (ibfd
, isec
) != NULL
)
3135 if (coff_section_data (obfd
, osec
) == NULL
)
3137 size_t amt
= sizeof (struct coff_section_tdata
);
3138 osec
->used_by_bfd
= bfd_zalloc (obfd
, amt
);
3139 if (osec
->used_by_bfd
== NULL
)
3143 if (pei_section_data (obfd
, osec
) == NULL
)
3145 size_t amt
= sizeof (struct pei_section_tdata
);
3146 coff_section_data (obfd
, osec
)->tdata
= bfd_zalloc (obfd
, amt
);
3147 if (coff_section_data (obfd
, osec
)->tdata
== NULL
)
3151 pei_section_data (obfd
, osec
)->virt_size
=
3152 pei_section_data (ibfd
, isec
)->virt_size
;
3153 pei_section_data (obfd
, osec
)->pe_flags
=
3154 pei_section_data (ibfd
, isec
)->pe_flags
;
3161 _bfd_XX_get_symbol_info (bfd
* abfd
, asymbol
*symbol
, symbol_info
*ret
)
3163 coff_get_symbol_info (abfd
, symbol
, ret
);
3166 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
3168 sort_x64_pdata (const void *l
, const void *r
)
3170 const char *lp
= (const char *) l
;
3171 const char *rp
= (const char *) r
;
3173 vl
= bfd_getl32 (lp
); vr
= bfd_getl32 (rp
);
3175 return (vl
< vr
? -1 : 1);
3176 /* We compare just begin address. */
3181 /* Functions to process a .rsrc section. */
3183 static unsigned int sizeof_leaves
;
3184 static unsigned int sizeof_strings
;
3185 static unsigned int sizeof_tables_and_entries
;
3188 rsrc_count_directory (bfd
*, bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
3191 rsrc_count_entries (bfd
* abfd
,
3192 bfd_boolean is_name
,
3193 bfd_byte
* datastart
,
3198 unsigned long entry
, addr
, size
;
3200 if (data
+ 8 >= dataend
)
3207 entry
= (long) bfd_get_32 (abfd
, data
);
3209 if (HighBitSet (entry
))
3210 name
= datastart
+ WithoutHighBit (entry
);
3212 name
= datastart
+ entry
- rva_bias
;
3214 if (name
+ 2 >= dataend
|| name
< datastart
)
3217 unsigned int len
= bfd_get_16 (abfd
, name
);
3218 if (len
== 0 || len
> 256)
3222 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
3224 if (HighBitSet (entry
))
3226 data
= datastart
+ WithoutHighBit (entry
);
3228 if (data
<= datastart
|| data
>= dataend
)
3231 return rsrc_count_directory (abfd
, datastart
, data
, dataend
, rva_bias
);
3234 if (datastart
+ entry
+ 16 >= dataend
)
3237 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
);
3238 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4);
3240 return datastart
+ addr
- rva_bias
+ size
;
3244 rsrc_count_directory (bfd
* abfd
,
3245 bfd_byte
* datastart
,
3250 unsigned int num_entries
, num_ids
;
3251 bfd_byte
* highest_data
= data
;
3253 if (data
+ 16 >= dataend
)
3256 num_entries
= (int) bfd_get_16 (abfd
, data
+ 12);
3257 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14);
3259 num_entries
+= num_ids
;
3263 while (num_entries
--)
3265 bfd_byte
* entry_end
;
3267 entry_end
= rsrc_count_entries (abfd
, num_entries
>= num_ids
,
3268 datastart
, data
, dataend
, rva_bias
);
3270 highest_data
= max (highest_data
, entry_end
);
3271 if (entry_end
>= dataend
)
3275 return max (highest_data
, data
);
3278 typedef struct rsrc_dir_chain
3280 unsigned int num_entries
;
3281 struct rsrc_entry
* first_entry
;
3282 struct rsrc_entry
* last_entry
;
3285 typedef struct rsrc_directory
3287 unsigned int characteristics
;
3292 rsrc_dir_chain names
;
3295 struct rsrc_entry
* entry
;
3298 typedef struct rsrc_string
3304 typedef struct rsrc_leaf
3307 unsigned int codepage
;
3311 typedef struct rsrc_entry
3313 bfd_boolean is_name
;
3317 struct rsrc_string name
;
3323 struct rsrc_directory
* directory
;
3324 struct rsrc_leaf
* leaf
;
3327 struct rsrc_entry
* next_entry
;
3328 struct rsrc_directory
* parent
;
3332 rsrc_parse_directory (bfd
*, rsrc_directory
*, bfd_byte
*,
3333 bfd_byte
*, bfd_byte
*, bfd_vma
, rsrc_entry
*);
3336 rsrc_parse_entry (bfd
* abfd
,
3337 bfd_boolean is_name
,
3339 bfd_byte
* datastart
,
3343 rsrc_directory
* parent
)
3345 unsigned long val
, addr
, size
;
3347 val
= bfd_get_32 (abfd
, data
);
3349 entry
->parent
= parent
;
3350 entry
->is_name
= is_name
;
3356 if (HighBitSet (val
))
3358 val
= WithoutHighBit (val
);
3360 address
= datastart
+ val
;
3364 address
= datastart
+ val
- rva_bias
;
3367 if (address
+ 3 > dataend
)
3370 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, address
);
3371 entry
->name_id
.name
.string
= address
+ 2;
3374 entry
->name_id
.id
= val
;
3376 val
= bfd_get_32 (abfd
, data
+ 4);
3378 if (HighBitSet (val
))
3380 entry
->is_dir
= TRUE
;
3381 entry
->value
.directory
= bfd_malloc (sizeof * entry
->value
.directory
);
3382 if (entry
->value
.directory
== NULL
)
3385 return rsrc_parse_directory (abfd
, entry
->value
.directory
,
3387 datastart
+ WithoutHighBit (val
),
3388 dataend
, rva_bias
, entry
);
3391 entry
->is_dir
= FALSE
;
3392 entry
->value
.leaf
= bfd_malloc (sizeof * entry
->value
.leaf
);
3393 if (entry
->value
.leaf
== NULL
)
3396 data
= datastart
+ val
;
3397 if (data
< datastart
|| data
>= dataend
)
3400 addr
= bfd_get_32 (abfd
, data
);
3401 size
= entry
->value
.leaf
->size
= bfd_get_32 (abfd
, data
+ 4);
3402 entry
->value
.leaf
->codepage
= bfd_get_32 (abfd
, data
+ 8);
3403 /* FIXME: We assume that the reserved field (data + 12) is OK. */
3405 entry
->value
.leaf
->data
= bfd_malloc (size
);
3406 if (entry
->value
.leaf
->data
== NULL
)
3409 memcpy (entry
->value
.leaf
->data
, datastart
+ addr
- rva_bias
, size
);
3410 return datastart
+ (addr
- rva_bias
) + size
;
3414 rsrc_parse_entries (bfd
* abfd
,
3415 rsrc_dir_chain
* chain
,
3416 bfd_boolean is_name
,
3417 bfd_byte
* highest_data
,
3418 bfd_byte
* datastart
,
3422 rsrc_directory
* parent
)
3427 if (chain
->num_entries
== 0)
3429 chain
->first_entry
= chain
->last_entry
= NULL
;
3430 return highest_data
;
3433 entry
= bfd_malloc (sizeof * entry
);
3437 chain
->first_entry
= entry
;
3439 for (i
= chain
->num_entries
; i
--;)
3441 bfd_byte
* entry_end
;
3443 entry_end
= rsrc_parse_entry (abfd
, is_name
, entry
, datastart
,
3444 data
, dataend
, rva_bias
, parent
);
3446 highest_data
= max (entry_end
, highest_data
);
3447 if (entry_end
> dataend
)
3452 entry
->next_entry
= bfd_malloc (sizeof * entry
);
3453 entry
= entry
->next_entry
;
3458 entry
->next_entry
= NULL
;
3461 chain
->last_entry
= entry
;
3463 return highest_data
;
3467 rsrc_parse_directory (bfd
* abfd
,
3468 rsrc_directory
* table
,
3469 bfd_byte
* datastart
,
3475 bfd_byte
* highest_data
= data
;
3480 table
->characteristics
= bfd_get_32 (abfd
, data
);
3481 table
->time
= bfd_get_32 (abfd
, data
+ 4);
3482 table
->major
= bfd_get_16 (abfd
, data
+ 8);
3483 table
->minor
= bfd_get_16 (abfd
, data
+ 10);
3484 table
->names
.num_entries
= bfd_get_16 (abfd
, data
+ 12);
3485 table
->ids
.num_entries
= bfd_get_16 (abfd
, data
+ 14);
3486 table
->entry
= entry
;
3490 highest_data
= rsrc_parse_entries (abfd
, & table
->names
, TRUE
, data
,
3491 datastart
, data
, dataend
, rva_bias
, table
);
3492 data
+= table
->names
.num_entries
* 8;
3494 highest_data
= rsrc_parse_entries (abfd
, & table
->ids
, FALSE
, highest_data
,
3495 datastart
, data
, dataend
, rva_bias
, table
);
3496 data
+= table
->ids
.num_entries
* 8;
3498 return max (highest_data
, data
);
3501 typedef struct rsrc_write_data
3504 bfd_byte
* datastart
;
3505 bfd_byte
* next_table
;
3506 bfd_byte
* next_leaf
;
3507 bfd_byte
* next_string
;
3508 bfd_byte
* next_data
;
3513 rsrc_write_string (rsrc_write_data
* data
,
3514 rsrc_string
* string
)
3516 bfd_put_16 (data
->abfd
, string
->len
, data
->next_string
);
3517 memcpy (data
->next_string
+ 2, string
->string
, string
->len
* 2);
3518 data
->next_string
+= (string
->len
+ 1) * 2;
3521 static inline unsigned int
3522 rsrc_compute_rva (rsrc_write_data
* data
,
3525 return (addr
- data
->datastart
) + data
->rva_bias
;
3529 rsrc_write_leaf (rsrc_write_data
* data
,
3532 bfd_put_32 (data
->abfd
, rsrc_compute_rva (data
, data
->next_data
),
3534 bfd_put_32 (data
->abfd
, leaf
->size
, data
->next_leaf
+ 4);
3535 bfd_put_32 (data
->abfd
, leaf
->codepage
, data
->next_leaf
+ 8);
3536 bfd_put_32 (data
->abfd
, 0 /*reserved*/, data
->next_leaf
+ 12);
3537 data
->next_leaf
+= 16;
3539 memcpy (data
->next_data
, leaf
->data
, leaf
->size
);
3540 /* An undocumented feature of Windows resources is that each unit
3541 of raw data is 8-byte aligned... */
3542 data
->next_data
+= ((leaf
->size
+ 7) & ~7);
3545 static void rsrc_write_directory (rsrc_write_data
*, rsrc_directory
*);
3548 rsrc_write_entry (rsrc_write_data
* data
,
3554 bfd_put_32 (data
->abfd
,
3555 SetHighBit (data
->next_string
- data
->datastart
),
3557 rsrc_write_string (data
, & entry
->name_id
.name
);
3560 bfd_put_32 (data
->abfd
, entry
->name_id
.id
, where
);
3564 bfd_put_32 (data
->abfd
,
3565 SetHighBit (data
->next_table
- data
->datastart
),
3567 rsrc_write_directory (data
, entry
->value
.directory
);
3571 bfd_put_32 (data
->abfd
, data
->next_leaf
- data
->datastart
, where
+ 4);
3572 rsrc_write_leaf (data
, entry
->value
.leaf
);
3577 rsrc_compute_region_sizes (rsrc_directory
* dir
)
3579 struct rsrc_entry
* entry
;
3584 sizeof_tables_and_entries
+= 16;
3586 for (entry
= dir
->names
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3588 sizeof_tables_and_entries
+= 8;
3590 sizeof_strings
+= (entry
->name_id
.name
.len
+ 1) * 2;
3593 rsrc_compute_region_sizes (entry
->value
.directory
);
3595 sizeof_leaves
+= 16;
3598 for (entry
= dir
->ids
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3600 sizeof_tables_and_entries
+= 8;
3603 rsrc_compute_region_sizes (entry
->value
.directory
);
3605 sizeof_leaves
+= 16;
3610 rsrc_write_directory (rsrc_write_data
* data
,
3611 rsrc_directory
* dir
)
3615 bfd_byte
* next_entry
;
3618 bfd_put_32 (data
->abfd
, dir
->characteristics
, data
->next_table
);
3619 bfd_put_32 (data
->abfd
, 0 /*dir->time*/, data
->next_table
+ 4);
3620 bfd_put_16 (data
->abfd
, dir
->major
, data
->next_table
+ 8);
3621 bfd_put_16 (data
->abfd
, dir
->minor
, data
->next_table
+ 10);
3622 bfd_put_16 (data
->abfd
, dir
->names
.num_entries
, data
->next_table
+ 12);
3623 bfd_put_16 (data
->abfd
, dir
->ids
.num_entries
, data
->next_table
+ 14);
3625 /* Compute where the entries and the next table will be placed. */
3626 next_entry
= data
->next_table
+ 16;
3627 data
->next_table
= next_entry
+ (dir
->names
.num_entries
* 8)
3628 + (dir
->ids
.num_entries
* 8);
3629 nt
= data
->next_table
;
3631 /* Write the entries. */
3632 for (i
= dir
->names
.num_entries
, entry
= dir
->names
.first_entry
;
3633 i
> 0 && entry
!= NULL
;
3634 i
--, entry
= entry
->next_entry
)
3636 BFD_ASSERT (entry
->is_name
);
3637 rsrc_write_entry (data
, next_entry
, entry
);
3640 BFD_ASSERT (i
== 0);
3641 BFD_ASSERT (entry
== NULL
);
3643 for (i
= dir
->ids
.num_entries
, entry
= dir
->ids
.first_entry
;
3644 i
> 0 && entry
!= NULL
;
3645 i
--, entry
= entry
->next_entry
)
3647 BFD_ASSERT (! entry
->is_name
);
3648 rsrc_write_entry (data
, next_entry
, entry
);
3651 BFD_ASSERT (i
== 0);
3652 BFD_ASSERT (entry
== NULL
);
3653 BFD_ASSERT (nt
== next_entry
);
3656 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3657 /* Return the length (number of units) of the first character in S,
3658 putting its 'ucs4_t' representation in *PUC. */
3661 #if defined HAVE_WCTYPE_H
3662 u16_mbtouc (wint_t * puc
, const unsigned short * s
, unsigned int n
)
3664 u16_mbtouc (wchar_t * puc
, const unsigned short * s
, unsigned int n
)
3667 unsigned short c
= * s
;
3669 if (c
< 0xd800 || c
>= 0xe000)
3679 if (s
[1] >= 0xdc00 && s
[1] < 0xe000)
3681 *puc
= 0x10000 + ((c
- 0xd800) << 10) + (s
[1] - 0xdc00);
3687 /* Incomplete multibyte character. */
3693 /* Invalid multibyte character. */
3697 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3699 /* Perform a comparison of two entries. */
3701 rsrc_cmp (bfd_boolean is_name
, rsrc_entry
* a
, rsrc_entry
* b
)
3710 return a
->name_id
.id
- b
->name_id
.id
;
3712 /* We have to perform a case insenstive, unicode string comparison... */
3713 astring
= a
->name_id
.name
.string
;
3714 alen
= a
->name_id
.name
.len
;
3715 bstring
= b
->name_id
.name
.string
;
3716 blen
= b
->name_id
.name
.len
;
3718 #if defined __CYGWIN__ || defined __MINGW32__
3719 /* Under Windows hosts (both Cygwin and Mingw types),
3720 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3721 function however goes by different names in the two environments... */
3725 #define rscpcmp wcsncasecmp
3728 #define rscpcmp wcsnicmp
3731 res
= rscpcmp ((const wchar_t *) astring
, (const wchar_t *) bstring
,
3734 #elif defined HAVE_WCHAR_H
3739 for (i
= min (alen
, blen
); i
--; astring
+= 2, bstring
+= 2)
3741 #if defined HAVE_WCTYPE_H
3749 /* Convert UTF-16 unicode characters into wchar_t characters
3750 so that we can then perform a case insensitive comparison. */
3751 unsigned int Alen
= u16_mbtouc (& awc
, (const unsigned short *) astring
, 2);
3752 unsigned int Blen
= u16_mbtouc (& bwc
, (const unsigned short *) bstring
, 2);
3757 #ifdef HAVE_WCTYPE_H
3758 awc
= towlower (awc
);
3759 bwc
= towlower (bwc
);
3763 res
= wcsncasecmp (& awc
, & bwc
, 1);
3770 /* Do the best we can - a case sensitive, untranslated comparison. */
3771 res
= memcmp (astring
, bstring
, min (alen
, blen
) * 2);
3781 rsrc_print_name (char * buffer
, rsrc_string string
)
3784 bfd_byte
* name
= string
.string
;
3786 for (i
= string
.len
; i
--; name
+= 2)
3787 sprintf (buffer
+ strlen (buffer
), "%.1s", name
);
3791 rsrc_resource_name (rsrc_entry
* entry
, rsrc_directory
* dir
)
3793 static char buffer
[256];
3794 bfd_boolean is_string
= FALSE
;
3798 if (dir
!= NULL
&& dir
->entry
!= NULL
&& dir
->entry
->parent
!= NULL
3799 && dir
->entry
->parent
->entry
!= NULL
)
3801 strcpy (buffer
, "type: ");
3802 if (dir
->entry
->parent
->entry
->is_name
)
3803 rsrc_print_name (buffer
+ strlen (buffer
),
3804 dir
->entry
->parent
->entry
->name_id
.name
);
3807 unsigned int id
= dir
->entry
->parent
->entry
->name_id
.id
;
3809 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3812 case 1: strcat (buffer
, " (CURSOR)"); break;
3813 case 2: strcat (buffer
, " (BITMAP)"); break;
3814 case 3: strcat (buffer
, " (ICON)"); break;
3815 case 4: strcat (buffer
, " (MENU)"); break;
3816 case 5: strcat (buffer
, " (DIALOG)"); break;
3817 case 6: strcat (buffer
, " (STRING)"); is_string
= TRUE
; break;
3818 case 7: strcat (buffer
, " (FONTDIR)"); break;
3819 case 8: strcat (buffer
, " (FONT)"); break;
3820 case 9: strcat (buffer
, " (ACCELERATOR)"); break;
3821 case 10: strcat (buffer
, " (RCDATA)"); break;
3822 case 11: strcat (buffer
, " (MESSAGETABLE)"); break;
3823 case 12: strcat (buffer
, " (GROUP_CURSOR)"); break;
3824 case 14: strcat (buffer
, " (GROUP_ICON)"); break;
3825 case 16: strcat (buffer
, " (VERSION)"); break;
3826 case 17: strcat (buffer
, " (DLGINCLUDE)"); break;
3827 case 19: strcat (buffer
, " (PLUGPLAY)"); break;
3828 case 20: strcat (buffer
, " (VXD)"); break;
3829 case 21: strcat (buffer
, " (ANICURSOR)"); break;
3830 case 22: strcat (buffer
, " (ANIICON)"); break;
3831 case 23: strcat (buffer
, " (HTML)"); break;
3832 case 24: strcat (buffer
, " (MANIFEST)"); break;
3833 case 240: strcat (buffer
, " (DLGINIT)"); break;
3834 case 241: strcat (buffer
, " (TOOLBAR)"); break;
3839 if (dir
!= NULL
&& dir
->entry
!= NULL
)
3841 strcat (buffer
, " name: ");
3842 if (dir
->entry
->is_name
)
3843 rsrc_print_name (buffer
+ strlen (buffer
), dir
->entry
->name_id
.name
);
3846 unsigned int id
= dir
->entry
->name_id
.id
;
3848 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3851 sprintf (buffer
+ strlen (buffer
), " (resource id range: %d - %d)",
3852 (id
- 1) << 4, (id
<< 4) - 1);
3858 strcat (buffer
, " lang: ");
3861 rsrc_print_name (buffer
+ strlen (buffer
), entry
->name_id
.name
);
3863 sprintf (buffer
+ strlen (buffer
), "%x", entry
->name_id
.id
);
3869 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3870 their ID is stored in the NAME entry. The bottom four bits are used as
3871 an index into unicode string table that makes up the data of the leaf.
3872 So identical type-name-lang string resources may not actually be
3875 This function is called when we have detected two string resources with
3876 match top-28-bit IDs. We have to scan the string tables inside the leaves
3877 and discover if there are any real collisions. If there are then we report
3878 them and return FALSE. Otherwise we copy any strings from B into A and
3879 then return TRUE. */
3882 rsrc_merge_string_entries (rsrc_entry
* a ATTRIBUTE_UNUSED
,
3883 rsrc_entry
* b ATTRIBUTE_UNUSED
)
3885 unsigned int copy_needed
= 0;
3889 bfd_byte
* new_data
;
3892 /* Step one: Find out what we have to do. */
3893 BFD_ASSERT (! a
->is_dir
);
3894 astring
= a
->value
.leaf
->data
;
3896 BFD_ASSERT (! b
->is_dir
);
3897 bstring
= b
->value
.leaf
->data
;
3899 for (i
= 0; i
< 16; i
++)
3901 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3902 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3906 copy_needed
+= blen
* 2;
3910 else if (alen
!= blen
)
3911 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3913 /* alen == blen != 0. We might have two identical strings. If so we
3914 can ignore the second one. There is no need for wchar_t vs UTF-16
3915 theatrics here - we are only interested in (case sensitive) equality. */
3916 else if (memcmp (astring
+ 2, bstring
+ 2, alen
* 2) != 0)
3919 astring
+= (alen
+ 1) * 2;
3920 bstring
+= (blen
+ 1) * 2;
3925 if (a
->parent
!= NULL
3926 && a
->parent
->entry
!= NULL
3927 && !a
->parent
->entry
->is_name
)
3928 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3929 ((a
->parent
->entry
->name_id
.id
- 1) << 4) + i
);
3933 if (copy_needed
== 0)
3936 /* If we reach here then A and B must both have non-colliding strings.
3937 (We never get string resources with fully empty string tables).
3938 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3940 new_data
= bfd_malloc (a
->value
.leaf
->size
+ copy_needed
);
3941 if (new_data
== NULL
)
3945 astring
= a
->value
.leaf
->data
;
3946 bstring
= b
->value
.leaf
->data
;
3948 for (i
= 0; i
< 16; i
++)
3950 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3951 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3955 memcpy (nstring
, astring
, (alen
+ 1) * 2);
3956 nstring
+= (alen
+ 1) * 2;
3960 memcpy (nstring
, bstring
, (blen
+ 1) * 2);
3961 nstring
+= (blen
+ 1) * 2;
3969 astring
+= (alen
+ 1) * 2;
3970 bstring
+= (blen
+ 1) * 2;
3973 BFD_ASSERT (nstring
- new_data
== (signed) (a
->value
.leaf
->size
+ copy_needed
));
3975 free (a
->value
.leaf
->data
);
3976 a
->value
.leaf
->data
= new_data
;
3977 a
->value
.leaf
->size
+= copy_needed
;
3982 static void rsrc_merge (rsrc_entry
*, rsrc_entry
*);
3984 /* Sort the entries in given part of the directory.
3985 We use an old fashioned bubble sort because we are dealing
3986 with lists and we want to handle matches specially. */
3989 rsrc_sort_entries (rsrc_dir_chain
* chain
,
3990 bfd_boolean is_name
,
3991 rsrc_directory
* dir
)
3995 rsrc_entry
** points_to_entry
;
3996 bfd_boolean swapped
;
3998 if (chain
->num_entries
< 2)
4004 points_to_entry
= & chain
->first_entry
;
4005 entry
= * points_to_entry
;
4006 next
= entry
->next_entry
;
4010 signed int cmp
= rsrc_cmp (is_name
, entry
, next
);
4014 entry
->next_entry
= next
->next_entry
;
4015 next
->next_entry
= entry
;
4016 * points_to_entry
= next
;
4017 points_to_entry
= & next
->next_entry
;
4018 next
= entry
->next_entry
;
4023 if (entry
->is_dir
&& next
->is_dir
)
4025 /* When we encounter identical directory entries we have to
4026 merge them together. The exception to this rule is for
4027 resource manifests - there can only be one of these,
4028 even if they differ in language. Zero-language manifests
4029 are assumed to be default manifests (provided by the
4030 Cygwin/MinGW build system) and these can be silently dropped,
4031 unless that would reduce the number of manifests to zero.
4032 There should only ever be one non-zero lang manifest -
4033 if there are more it is an error. A non-zero lang
4034 manifest takes precedence over a default manifest. */
4036 && entry
->name_id
.id
== 1
4038 && dir
->entry
!= NULL
4039 && !dir
->entry
->is_name
4040 && dir
->entry
->name_id
.id
== 0x18)
4042 if (next
->value
.directory
->names
.num_entries
== 0
4043 && next
->value
.directory
->ids
.num_entries
== 1
4044 && !next
->value
.directory
->ids
.first_entry
->is_name
4045 && next
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
4046 /* Fall through so that NEXT is dropped. */
4048 else if (entry
->value
.directory
->names
.num_entries
== 0
4049 && entry
->value
.directory
->ids
.num_entries
== 1
4050 && !entry
->value
.directory
->ids
.first_entry
->is_name
4051 && entry
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
4053 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
4054 entry
->next_entry
= next
->next_entry
;
4055 next
->next_entry
= entry
;
4056 * points_to_entry
= next
;
4057 points_to_entry
= & next
->next_entry
;
4058 next
= entry
->next_entry
;
4063 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
4064 bfd_set_error (bfd_error_file_truncated
);
4068 /* Unhook NEXT from the chain. */
4069 /* FIXME: memory loss here. */
4070 entry
->next_entry
= next
->next_entry
;
4071 chain
->num_entries
--;
4072 if (chain
->num_entries
< 2)
4074 next
= next
->next_entry
;
4077 rsrc_merge (entry
, next
);
4079 else if (entry
->is_dir
!= next
->is_dir
)
4081 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
4082 bfd_set_error (bfd_error_file_truncated
);
4087 /* Otherwise with identical leaves we issue an error
4088 message - because there should never be duplicates.
4089 The exception is Type 18/Name 1/Lang 0 which is the
4090 defaul manifest - this can just be dropped. */
4092 && entry
->name_id
.id
== 0
4094 && dir
->entry
!= NULL
4095 && !dir
->entry
->is_name
4096 && dir
->entry
->name_id
.id
== 1
4097 && dir
->entry
->parent
!= NULL
4098 && dir
->entry
->parent
->entry
!= NULL
4099 && !dir
->entry
->parent
->entry
->is_name
4100 && dir
->entry
->parent
->entry
->name_id
.id
== 0x18 /* RT_MANIFEST */)
4102 else if (dir
!= NULL
4103 && dir
->entry
!= NULL
4104 && dir
->entry
->parent
!= NULL
4105 && dir
->entry
->parent
->entry
!= NULL
4106 && !dir
->entry
->parent
->entry
->is_name
4107 && dir
->entry
->parent
->entry
->name_id
.id
== 0x6 /* RT_STRING */)
4109 /* Strings need special handling. */
4110 if (! rsrc_merge_string_entries (entry
, next
))
4112 /* _bfd_error_handler should have been called inside merge_strings. */
4113 bfd_set_error (bfd_error_file_truncated
);
4120 || dir
->entry
== NULL
4121 || dir
->entry
->parent
== NULL
4122 || dir
->entry
->parent
->entry
== NULL
)
4123 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
4125 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
4126 rsrc_resource_name (entry
, dir
));
4127 bfd_set_error (bfd_error_file_truncated
);
4132 /* Unhook NEXT from the chain. */
4133 entry
->next_entry
= next
->next_entry
;
4134 chain
->num_entries
--;
4135 if (chain
->num_entries
< 2)
4137 next
= next
->next_entry
;
4141 points_to_entry
= & entry
->next_entry
;
4143 next
= next
->next_entry
;
4148 chain
->last_entry
= entry
;
4153 /* Attach B's chain onto A. */
4155 rsrc_attach_chain (rsrc_dir_chain
* achain
, rsrc_dir_chain
* bchain
)
4157 if (bchain
->num_entries
== 0)
4160 achain
->num_entries
+= bchain
->num_entries
;
4162 if (achain
->first_entry
== NULL
)
4164 achain
->first_entry
= bchain
->first_entry
;
4165 achain
->last_entry
= bchain
->last_entry
;
4169 achain
->last_entry
->next_entry
= bchain
->first_entry
;
4170 achain
->last_entry
= bchain
->last_entry
;
4173 bchain
->num_entries
= 0;
4174 bchain
->first_entry
= bchain
->last_entry
= NULL
;
4178 rsrc_merge (struct rsrc_entry
* a
, struct rsrc_entry
* b
)
4180 rsrc_directory
* adir
;
4181 rsrc_directory
* bdir
;
4183 BFD_ASSERT (a
->is_dir
);
4184 BFD_ASSERT (b
->is_dir
);
4186 adir
= a
->value
.directory
;
4187 bdir
= b
->value
.directory
;
4189 if (adir
->characteristics
!= bdir
->characteristics
)
4191 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics"));
4192 bfd_set_error (bfd_error_file_truncated
);
4196 if (adir
->major
!= bdir
->major
|| adir
->minor
!= bdir
->minor
)
4198 _bfd_error_handler (_(".rsrc merge failure: differing directory versions"));
4199 bfd_set_error (bfd_error_file_truncated
);
4203 /* Attach B's name chain to A. */
4204 rsrc_attach_chain (& adir
->names
, & bdir
->names
);
4206 /* Attach B's ID chain to A. */
4207 rsrc_attach_chain (& adir
->ids
, & bdir
->ids
);
4209 /* Now sort A's entries. */
4210 rsrc_sort_entries (& adir
->names
, TRUE
, adir
);
4211 rsrc_sort_entries (& adir
->ids
, FALSE
, adir
);
4214 /* Check the .rsrc section. If it contains multiple concatenated
4215 resources then we must merge them properly. Otherwise Windows
4216 will ignore all but the first set. */
4219 rsrc_process_section (bfd
* abfd
,
4220 struct coff_final_link_info
* pfinfo
)
4222 rsrc_directory new_table
;
4228 bfd_byte
* datastart
;
4230 bfd_byte
* new_data
;
4231 unsigned int num_resource_sets
;
4232 rsrc_directory
* type_tables
;
4233 rsrc_write_data write_data
;
4236 unsigned int num_input_rsrc
= 0;
4237 unsigned int max_num_input_rsrc
= 4;
4238 ptrdiff_t * rsrc_sizes
= NULL
;
4240 new_table
.names
.num_entries
= 0;
4241 new_table
.ids
.num_entries
= 0;
4243 sec
= bfd_get_section_by_name (abfd
, ".rsrc");
4244 if (sec
== NULL
|| (size
= sec
->rawsize
) == 0)
4247 pe
= pe_data (abfd
);
4251 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4253 data
= bfd_malloc (size
);
4259 if (! bfd_get_section_contents (abfd
, sec
, data
, 0, size
))
4262 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4263 their lengths. Note - we rely upon the fact that the linker script
4264 does *not* sort the input .rsrc sections, so that the order in the
4265 linkinfo list matches the order in the output .rsrc section.
4267 We need to know the lengths because each input .rsrc section has padding
4268 at the end of a variable amount. (It does not appear to be based upon
4269 the section alignment or the file alignment). We need to skip any
4270 padding bytes when parsing the input .rsrc sections. */
4271 rsrc_sizes
= bfd_malloc (max_num_input_rsrc
* sizeof * rsrc_sizes
);
4272 if (rsrc_sizes
== NULL
)
4275 for (input
= pfinfo
->info
->input_bfds
;
4277 input
= input
->link
.next
)
4279 asection
* rsrc_sec
= bfd_get_section_by_name (input
, ".rsrc");
4281 /* PR 18372 - skip discarded .rsrc sections. */
4282 if (rsrc_sec
!= NULL
&& !discarded_section (rsrc_sec
))
4284 if (num_input_rsrc
== max_num_input_rsrc
)
4286 max_num_input_rsrc
+= 10;
4287 rsrc_sizes
= bfd_realloc (rsrc_sizes
, max_num_input_rsrc
4288 * sizeof * rsrc_sizes
);
4289 if (rsrc_sizes
== NULL
)
4293 BFD_ASSERT (rsrc_sec
->size
> 0);
4294 rsrc_sizes
[num_input_rsrc
++] = rsrc_sec
->size
;
4298 if (num_input_rsrc
< 2)
4301 /* Step one: Walk the section, computing the size of the tables,
4302 leaves and data and decide if we need to do anything. */
4303 dataend
= data
+ size
;
4304 num_resource_sets
= 0;
4306 while (data
< dataend
)
4308 bfd_byte
* p
= data
;
4310 data
= rsrc_count_directory (abfd
, data
, data
, dataend
, rva_bias
);
4314 /* Corrupted .rsrc section - cannot merge. */
4315 _bfd_error_handler (_("%pB: .rsrc merge failure: corrupt .rsrc section"),
4317 bfd_set_error (bfd_error_file_truncated
);
4321 if ((data
- p
) > rsrc_sizes
[num_resource_sets
])
4323 _bfd_error_handler (_("%pB: .rsrc merge failure: unexpected .rsrc size"),
4325 bfd_set_error (bfd_error_file_truncated
);
4328 /* FIXME: Should we add a check for "data - p" being much smaller
4329 than rsrc_sizes[num_resource_sets] ? */
4331 data
= p
+ rsrc_sizes
[num_resource_sets
];
4332 rva_bias
+= data
- p
;
4333 ++ num_resource_sets
;
4335 BFD_ASSERT (num_resource_sets
== num_input_rsrc
);
4337 /* Step two: Walk the data again, building trees of the resources. */
4339 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4341 type_tables
= bfd_malloc (num_resource_sets
* sizeof * type_tables
);
4342 if (type_tables
== NULL
)
4346 while (data
< dataend
)
4348 bfd_byte
* p
= data
;
4350 (void) rsrc_parse_directory (abfd
, type_tables
+ indx
, data
, data
,
4351 dataend
, rva_bias
, NULL
);
4352 data
= p
+ rsrc_sizes
[indx
];
4353 rva_bias
+= data
- p
;
4356 BFD_ASSERT (indx
== num_resource_sets
);
4358 /* Step three: Merge the top level tables (there can be only one).
4360 We must ensure that the merged entries are in ascending order.
4362 We also thread the top level table entries from the old tree onto
4363 the new table, so that they can be pulled off later. */
4365 /* FIXME: Should we verify that all type tables are the same ? */
4366 new_table
.characteristics
= type_tables
[0].characteristics
;
4367 new_table
.time
= type_tables
[0].time
;
4368 new_table
.major
= type_tables
[0].major
;
4369 new_table
.minor
= type_tables
[0].minor
;
4371 /* Chain the NAME entries onto the table. */
4372 new_table
.names
.first_entry
= NULL
;
4373 new_table
.names
.last_entry
= NULL
;
4375 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4376 rsrc_attach_chain (& new_table
.names
, & type_tables
[indx
].names
);
4378 rsrc_sort_entries (& new_table
.names
, TRUE
, & new_table
);
4380 /* Chain the ID entries onto the table. */
4381 new_table
.ids
.first_entry
= NULL
;
4382 new_table
.ids
.last_entry
= NULL
;
4384 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4385 rsrc_attach_chain (& new_table
.ids
, & type_tables
[indx
].ids
);
4387 rsrc_sort_entries (& new_table
.ids
, FALSE
, & new_table
);
4389 /* Step four: Create new contents for the .rsrc section. */
4390 /* Step four point one: Compute the size of each region of the .rsrc section.
4391 We do this now, rather than earlier, as the merging above may have dropped
4393 sizeof_leaves
= sizeof_strings
= sizeof_tables_and_entries
= 0;
4394 rsrc_compute_region_sizes (& new_table
);
4395 /* We increment sizeof_strings to make sure that resource data
4396 starts on an 8-byte boundary. FIXME: Is this correct ? */
4397 sizeof_strings
= (sizeof_strings
+ 7) & ~ 7;
4399 new_data
= bfd_zalloc (abfd
, size
);
4400 if (new_data
== NULL
)
4403 write_data
.abfd
= abfd
;
4404 write_data
.datastart
= new_data
;
4405 write_data
.next_table
= new_data
;
4406 write_data
.next_leaf
= new_data
+ sizeof_tables_and_entries
;
4407 write_data
.next_string
= write_data
.next_leaf
+ sizeof_leaves
;
4408 write_data
.next_data
= write_data
.next_string
+ sizeof_strings
;
4409 write_data
.rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4411 rsrc_write_directory (& write_data
, & new_table
);
4413 /* Step five: Replace the old contents with the new.
4414 We don't recompute the size as it's too late here to shrink section.
4415 See PR ld/20193 for more details. */
4416 bfd_set_section_contents (pfinfo
->output_bfd
, sec
, new_data
, 0, size
);
4417 sec
->size
= sec
->rawsize
= size
;
4420 /* Step six: Free all the memory that we have used. */
4421 /* FIXME: Free the resource tree, if we have one. */
4426 /* Handle the .idata section and other things that need symbol table
4430 _bfd_XXi_final_link_postscript (bfd
* abfd
, struct coff_final_link_info
*pfinfo
)
4432 struct coff_link_hash_entry
*h1
;
4433 struct bfd_link_info
*info
= pfinfo
->info
;
4434 bfd_boolean result
= TRUE
;
4436 /* There are a few fields that need to be filled in now while we
4437 have symbol table access.
4439 The .idata subsections aren't directly available as sections, but
4440 they are in the symbol table, so get them from there. */
4442 /* The import directory. This is the address of .idata$2, with size
4443 of .idata$2 + .idata$3. */
4444 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4445 ".idata$2", FALSE
, FALSE
, TRUE
);
4448 /* PR ld/2729: We cannot rely upon all the output sections having been
4449 created properly, so check before referencing them. Issue a warning
4450 message for any sections tht could not be found. */
4451 if ((h1
->root
.type
== bfd_link_hash_defined
4452 || h1
->root
.type
== bfd_link_hash_defweak
)
4453 && h1
->root
.u
.def
.section
!= NULL
4454 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4455 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
=
4456 (h1
->root
.u
.def
.value
4457 + h1
->root
.u
.def
.section
->output_section
->vma
4458 + h1
->root
.u
.def
.section
->output_offset
);
4462 (_("%pB: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4467 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4468 ".idata$4", FALSE
, FALSE
, TRUE
);
4470 && (h1
->root
.type
== bfd_link_hash_defined
4471 || h1
->root
.type
== bfd_link_hash_defweak
)
4472 && h1
->root
.u
.def
.section
!= NULL
4473 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4474 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].Size
=
4475 ((h1
->root
.u
.def
.value
4476 + h1
->root
.u
.def
.section
->output_section
->vma
4477 + h1
->root
.u
.def
.section
->output_offset
)
4478 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
);
4482 (_("%pB: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4487 /* The import address table. This is the size/address of
4489 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4490 ".idata$5", FALSE
, FALSE
, TRUE
);
4492 && (h1
->root
.type
== bfd_link_hash_defined
4493 || h1
->root
.type
== bfd_link_hash_defweak
)
4494 && h1
->root
.u
.def
.section
!= NULL
4495 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4496 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4497 (h1
->root
.u
.def
.value
4498 + h1
->root
.u
.def
.section
->output_section
->vma
4499 + h1
->root
.u
.def
.section
->output_offset
);
4503 (_("%pB: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4508 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4509 ".idata$6", FALSE
, FALSE
, TRUE
);
4511 && (h1
->root
.type
== bfd_link_hash_defined
4512 || h1
->root
.type
== bfd_link_hash_defweak
)
4513 && h1
->root
.u
.def
.section
!= NULL
4514 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4515 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4516 ((h1
->root
.u
.def
.value
4517 + h1
->root
.u
.def
.section
->output_section
->vma
4518 + h1
->root
.u
.def
.section
->output_offset
)
4519 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
);
4523 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4530 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4531 "__IAT_start__", FALSE
, FALSE
, TRUE
);
4533 && (h1
->root
.type
== bfd_link_hash_defined
4534 || h1
->root
.type
== bfd_link_hash_defweak
)
4535 && h1
->root
.u
.def
.section
!= NULL
4536 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4541 (h1
->root
.u
.def
.value
4542 + h1
->root
.u
.def
.section
->output_section
->vma
4543 + h1
->root
.u
.def
.section
->output_offset
);
4545 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4546 "__IAT_end__", FALSE
, FALSE
, TRUE
);
4548 && (h1
->root
.type
== bfd_link_hash_defined
4549 || h1
->root
.type
== bfd_link_hash_defweak
)
4550 && h1
->root
.u
.def
.section
!= NULL
4551 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4553 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4554 ((h1
->root
.u
.def
.value
4555 + h1
->root
.u
.def
.section
->output_section
->vma
4556 + h1
->root
.u
.def
.section
->output_offset
)
4558 if (pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
!= 0)
4559 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4560 iat_va
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
4565 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4566 " because .idata$6 is missing"), abfd
);
4572 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4573 (bfd_get_symbol_leading_char (abfd
) != 0
4574 ? "__tls_used" : "_tls_used"),
4575 FALSE
, FALSE
, TRUE
);
4578 if ((h1
->root
.type
== bfd_link_hash_defined
4579 || h1
->root
.type
== bfd_link_hash_defweak
)
4580 && h1
->root
.u
.def
.section
!= NULL
4581 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4582 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].VirtualAddress
=
4583 (h1
->root
.u
.def
.value
4584 + h1
->root
.u
.def
.section
->output_section
->vma
4585 + h1
->root
.u
.def
.section
->output_offset
4586 - pe_data (abfd
)->pe_opthdr
.ImageBase
);
4590 (_("%pB: unable to fill in DataDictionary[9] because __tls_used is missing"),
4594 /* According to PECOFF sepcifications by Microsoft version 8.2
4595 the TLS data directory consists of 4 pointers, followed
4596 by two 4-byte integer. This implies that the total size
4597 is different for 32-bit and 64-bit executables. */
4598 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4599 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x18;
4601 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x28;
4605 /* If there is a .pdata section and we have linked pdata finally, we
4606 need to sort the entries ascending. */
4607 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4609 asection
*sec
= bfd_get_section_by_name (abfd
, ".pdata");
4613 bfd_size_type x
= sec
->rawsize
;
4614 bfd_byte
*tmp_data
= NULL
;
4617 tmp_data
= bfd_malloc (x
);
4619 if (tmp_data
!= NULL
)
4621 if (bfd_get_section_contents (abfd
, sec
, tmp_data
, 0, x
))
4625 12, sort_x64_pdata
);
4626 bfd_set_section_contents (pfinfo
->output_bfd
, sec
,
4637 rsrc_process_section (abfd
, pfinfo
);
4639 /* If we couldn't find idata$2, we either have an excessively
4640 trivial program or are in DEEP trouble; we have to assume trivial