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
)
1151 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1154 if (bfd_bread (buffer
, 256, abfd
) < 4)
1157 /* Ensure null termination of filename. */
1160 cvinfo
->CVSignature
= H_GET_32 (abfd
, buffer
);
1163 if ((cvinfo
->CVSignature
== CVINFO_PDB70_CVSIGNATURE
)
1164 && (length
> sizeof (CV_INFO_PDB70
)))
1166 CV_INFO_PDB70
*cvinfo70
= (CV_INFO_PDB70
*)(buffer
);
1168 cvinfo
->Age
= H_GET_32(abfd
, cvinfo70
->Age
);
1170 /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1171 by 8 single bytes. Byte swap them so we can conveniently treat the GUID
1172 as 16 bytes in big-endian order. */
1173 bfd_putb32 (bfd_getl32 (cvinfo70
->Signature
), cvinfo
->Signature
);
1174 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[4])), &(cvinfo
->Signature
[4]));
1175 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[6])), &(cvinfo
->Signature
[6]));
1176 memcpy (&(cvinfo
->Signature
[8]), &(cvinfo70
->Signature
[8]), 8);
1178 cvinfo
->SignatureLength
= CV_INFO_SIGNATURE_LENGTH
;
1179 // cvinfo->PdbFileName = cvinfo70->PdbFileName;
1183 else if ((cvinfo
->CVSignature
== CVINFO_PDB20_CVSIGNATURE
)
1184 && (length
> sizeof (CV_INFO_PDB20
)))
1186 CV_INFO_PDB20
*cvinfo20
= (CV_INFO_PDB20
*)(buffer
);
1187 cvinfo
->Age
= H_GET_32(abfd
, cvinfo20
->Age
);
1188 memcpy (cvinfo
->Signature
, cvinfo20
->Signature
, 4);
1189 cvinfo
->SignatureLength
= 4;
1190 // cvinfo->PdbFileName = cvinfo20->PdbFileName;
1199 _bfd_XXi_write_codeview_record (bfd
* abfd
, file_ptr where
, CODEVIEW_INFO
*cvinfo
)
1201 const bfd_size_type size
= sizeof (CV_INFO_PDB70
) + 1;
1202 bfd_size_type written
;
1203 CV_INFO_PDB70
*cvinfo70
;
1206 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1209 buffer
= bfd_malloc (size
);
1213 cvinfo70
= (CV_INFO_PDB70
*) buffer
;
1214 H_PUT_32 (abfd
, CVINFO_PDB70_CVSIGNATURE
, cvinfo70
->CvSignature
);
1216 /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1217 in little-endian order, followed by 8 single bytes. */
1218 bfd_putl32 (bfd_getb32 (cvinfo
->Signature
), cvinfo70
->Signature
);
1219 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[4])), &(cvinfo70
->Signature
[4]));
1220 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[6])), &(cvinfo70
->Signature
[6]));
1221 memcpy (&(cvinfo70
->Signature
[8]), &(cvinfo
->Signature
[8]), 8);
1223 H_PUT_32 (abfd
, cvinfo
->Age
, cvinfo70
->Age
);
1224 cvinfo70
->PdbFileName
[0] = '\0';
1226 written
= bfd_bwrite (buffer
, size
, abfd
);
1230 return written
== size
? size
: 0;
1233 static char * dir_names
[IMAGE_NUMBEROF_DIRECTORY_ENTRIES
] =
1235 N_("Export Directory [.edata (or where ever we found it)]"),
1236 N_("Import Directory [parts of .idata]"),
1237 N_("Resource Directory [.rsrc]"),
1238 N_("Exception Directory [.pdata]"),
1239 N_("Security Directory"),
1240 N_("Base Relocation Directory [.reloc]"),
1241 N_("Debug Directory"),
1242 N_("Description Directory"),
1243 N_("Special Directory"),
1244 N_("Thread Storage Directory [.tls]"),
1245 N_("Load Configuration Directory"),
1246 N_("Bound Import Directory"),
1247 N_("Import Address Table Directory"),
1248 N_("Delay Import Directory"),
1249 N_("CLR Runtime Header"),
1253 #ifdef POWERPC_LE_PE
1254 /* The code for the PPC really falls in the "architecture dependent"
1255 category. However, it's not clear that anyone will ever care, so
1256 we're ignoring the issue for now; if/when PPC matters, some of this
1257 may need to go into peicode.h, or arguments passed to enable the
1258 PPC- specific code. */
1262 pe_print_idata (bfd
* abfd
, void * vfile
)
1264 FILE *file
= (FILE *) vfile
;
1269 #ifdef POWERPC_LE_PE
1270 asection
*rel_section
= bfd_get_section_by_name (abfd
, ".reldata");
1273 bfd_size_type datasize
= 0;
1274 bfd_size_type dataoff
;
1278 pe_data_type
*pe
= pe_data (abfd
);
1279 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1283 addr
= extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
;
1285 if (addr
== 0 && extra
->DataDirectory
[PE_IMPORT_TABLE
].Size
== 0)
1287 /* Maybe the extra header isn't there. Look for the section. */
1288 section
= bfd_get_section_by_name (abfd
, ".idata");
1289 if (section
== NULL
)
1292 addr
= section
->vma
;
1293 datasize
= section
->size
;
1299 addr
+= extra
->ImageBase
;
1300 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1302 datasize
= section
->size
;
1303 if (addr
>= section
->vma
&& addr
< section
->vma
+ datasize
)
1307 if (section
== NULL
)
1310 _("\nThere is an import table, but the section containing it could not be found\n"));
1313 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1316 _("\nThere is an import table in %s, but that section has no contents\n"),
1322 /* xgettext:c-format */
1323 fprintf (file
, _("\nThere is an import table in %s at 0x%lx\n"),
1324 section
->name
, (unsigned long) addr
);
1326 dataoff
= addr
- section
->vma
;
1328 #ifdef POWERPC_LE_PE
1329 if (rel_section
!= 0 && rel_section
->size
!= 0)
1331 /* The toc address can be found by taking the starting address,
1332 which on the PPC locates a function descriptor. The
1333 descriptor consists of the function code starting address
1334 followed by the address of the toc. The starting address we
1335 get from the bfd, and the descriptor is supposed to be in the
1336 .reldata section. */
1338 bfd_vma loadable_toc_address
;
1339 bfd_vma toc_address
;
1340 bfd_vma start_address
;
1344 if (!bfd_malloc_and_get_section (abfd
, rel_section
, &data
))
1350 offset
= abfd
->start_address
- rel_section
->vma
;
1352 if (offset
>= rel_section
->size
|| offset
+ 8 > rel_section
->size
)
1358 start_address
= bfd_get_32 (abfd
, data
+ offset
);
1359 loadable_toc_address
= bfd_get_32 (abfd
, data
+ offset
+ 4);
1360 toc_address
= loadable_toc_address
- 32768;
1363 _("\nFunction descriptor located at the start address: %04lx\n"),
1364 (unsigned long int) (abfd
->start_address
));
1366 /* xgettext:c-format */
1367 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1368 start_address
, loadable_toc_address
, toc_address
);
1374 _("\nNo reldata section! Function descriptor not decoded.\n"));
1379 _("\nThe Import Tables (interpreted %s section contents)\n"),
1383 vma: Hint Time Forward DLL First\n\
1384 Table Stamp Chain Name Thunk\n"));
1386 /* Read the whole section. Some of the fields might be before dataoff. */
1387 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
1393 adj
= section
->vma
- extra
->ImageBase
;
1395 /* Print all image import descriptors. */
1396 for (i
= dataoff
; i
+ onaline
<= datasize
; i
+= onaline
)
1400 bfd_vma forward_chain
;
1402 bfd_vma first_thunk
;
1407 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1408 fprintf (file
, " %08lx\t", (unsigned long) (i
+ adj
));
1409 hint_addr
= bfd_get_32 (abfd
, data
+ i
);
1410 time_stamp
= bfd_get_32 (abfd
, data
+ i
+ 4);
1411 forward_chain
= bfd_get_32 (abfd
, data
+ i
+ 8);
1412 dll_name
= bfd_get_32 (abfd
, data
+ i
+ 12);
1413 first_thunk
= bfd_get_32 (abfd
, data
+ i
+ 16);
1415 fprintf (file
, "%08lx %08lx %08lx %08lx %08lx\n",
1416 (unsigned long) hint_addr
,
1417 (unsigned long) time_stamp
,
1418 (unsigned long) forward_chain
,
1419 (unsigned long) dll_name
,
1420 (unsigned long) first_thunk
);
1422 if (hint_addr
== 0 && first_thunk
== 0)
1425 if (dll_name
- adj
>= section
->size
)
1428 dll
= (char *) data
+ dll_name
- adj
;
1429 /* PR 17512 file: 078-12277-0.004. */
1430 bfd_size_type maxlen
= (char *)(data
+ datasize
) - dll
- 1;
1431 fprintf (file
, _("\n\tDLL Name: %.*s\n"), (int) maxlen
, dll
);
1433 /* PR 21546: When the Hint Address is zero,
1434 we try the First Thunk instead. */
1436 hint_addr
= first_thunk
;
1438 if (hint_addr
!= 0 && hint_addr
- adj
< datasize
)
1441 asection
*ft_section
;
1443 bfd_size_type ft_datasize
;
1447 fprintf (file
, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1449 idx
= hint_addr
- adj
;
1451 ft_addr
= first_thunk
+ extra
->ImageBase
;
1452 ft_idx
= first_thunk
- adj
;
1453 ft_data
= data
+ ft_idx
;
1454 ft_datasize
= datasize
- ft_idx
;
1457 if (first_thunk
!= hint_addr
)
1459 /* Find the section which contains the first thunk. */
1460 for (ft_section
= abfd
->sections
;
1462 ft_section
= ft_section
->next
)
1464 if (ft_addr
>= ft_section
->vma
1465 && ft_addr
< ft_section
->vma
+ ft_section
->size
)
1469 if (ft_section
== NULL
)
1472 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1476 /* Now check to see if this section is the same as our current
1477 section. If it is not then we will have to load its data in. */
1478 if (ft_section
!= section
)
1480 ft_idx
= first_thunk
- (ft_section
->vma
- extra
->ImageBase
);
1481 ft_datasize
= ft_section
->size
- ft_idx
;
1482 ft_data
= (bfd_byte
*) bfd_malloc (ft_datasize
);
1483 if (ft_data
== NULL
)
1486 /* Read ft_datasize bytes starting at offset ft_idx. */
1487 if (!bfd_get_section_contents (abfd
, ft_section
, ft_data
,
1488 (bfd_vma
) ft_idx
, ft_datasize
))
1497 /* Print HintName vector entries. */
1498 #ifdef COFF_WITH_pex64
1499 for (j
= 0; idx
+ j
+ 8 <= datasize
; j
+= 8)
1502 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1503 unsigned long member_high
= bfd_get_32 (abfd
, data
+ idx
+ j
+ 4);
1505 if (!member
&& !member_high
)
1510 if (HighBitSet (member_high
))
1511 fprintf (file
, "\t%lx%08lx\t %4lx%08lx <none>",
1512 member_high
, member
,
1513 WithoutHighBit (member_high
), member
);
1514 /* PR binutils/17512: Handle corrupt PE data. */
1515 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1516 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1522 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1523 member_name
= (char *) data
+ amt
+ 2;
1524 fprintf (file
, "\t%04lx\t %4d %.*s",member
, ordinal
,
1525 (int) (datasize
- (amt
+ 2)), member_name
);
1528 /* If the time stamp is not zero, the import address
1529 table holds actual addresses. */
1532 && first_thunk
!= hint_addr
1533 && j
+ 4 <= ft_datasize
)
1534 fprintf (file
, "\t%04lx",
1535 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1536 fprintf (file
, "\n");
1539 for (j
= 0; idx
+ j
+ 4 <= datasize
; j
+= 4)
1542 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1544 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1550 if (HighBitSet (member
))
1551 fprintf (file
, "\t%04lx\t %4lu <none>",
1552 member
, WithoutHighBit (member
));
1553 /* PR binutils/17512: Handle corrupt PE data. */
1554 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1555 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1561 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1562 member_name
= (char *) data
+ amt
+ 2;
1563 fprintf (file
, "\t%04lx\t %4d %.*s",
1565 (int) (datasize
- (amt
+ 2)), member_name
);
1568 /* If the time stamp is not zero, the import address
1569 table holds actual addresses. */
1572 && first_thunk
!= hint_addr
1573 && j
+ 4 <= ft_datasize
)
1574 fprintf (file
, "\t%04lx",
1575 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1577 fprintf (file
, "\n");
1584 fprintf (file
, "\n");
1593 pe_print_edata (bfd
* abfd
, void * vfile
)
1595 FILE *file
= (FILE *) vfile
;
1598 bfd_size_type datasize
= 0;
1599 bfd_size_type dataoff
;
1604 long export_flags
; /* Reserved - should be zero. */
1608 bfd_vma name
; /* RVA - relative to image base. */
1609 long base
; /* Ordinal base. */
1610 unsigned long num_functions
;/* Number in the export address table. */
1611 unsigned long num_names
; /* Number in the name pointer table. */
1612 bfd_vma eat_addr
; /* RVA to the export address table. */
1613 bfd_vma npt_addr
; /* RVA to the Export Name Pointer Table. */
1614 bfd_vma ot_addr
; /* RVA to the Ordinal Table. */
1617 pe_data_type
*pe
= pe_data (abfd
);
1618 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1622 addr
= extra
->DataDirectory
[PE_EXPORT_TABLE
].VirtualAddress
;
1624 if (addr
== 0 && extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
== 0)
1626 /* Maybe the extra header isn't there. Look for the section. */
1627 section
= bfd_get_section_by_name (abfd
, ".edata");
1628 if (section
== NULL
)
1631 addr
= section
->vma
;
1633 datasize
= section
->size
;
1639 addr
+= extra
->ImageBase
;
1641 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1642 if (addr
>= section
->vma
&& addr
< section
->vma
+ section
->size
)
1645 if (section
== NULL
)
1648 _("\nThere is an export table, but the section containing it could not be found\n"));
1651 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1654 _("\nThere is an export table in %s, but that section has no contents\n"),
1659 dataoff
= addr
- section
->vma
;
1660 datasize
= extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
;
1661 if (dataoff
> section
->size
1662 || datasize
> section
->size
- dataoff
)
1665 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1671 /* PR 17512: Handle corrupt PE binaries. */
1675 /* xgettext:c-format */
1676 _("\nThere is an export table in %s, but it is too small (%d)\n"),
1677 section
->name
, (int) datasize
);
1681 /* xgettext:c-format */
1682 fprintf (file
, _("\nThere is an export table in %s at 0x%lx\n"),
1683 section
->name
, (unsigned long) addr
);
1685 data
= (bfd_byte
*) bfd_malloc (datasize
);
1689 if (! bfd_get_section_contents (abfd
, section
, data
,
1690 (file_ptr
) dataoff
, datasize
))
1693 /* Go get Export Directory Table. */
1694 edt
.export_flags
= bfd_get_32 (abfd
, data
+ 0);
1695 edt
.time_stamp
= bfd_get_32 (abfd
, data
+ 4);
1696 edt
.major_ver
= bfd_get_16 (abfd
, data
+ 8);
1697 edt
.minor_ver
= bfd_get_16 (abfd
, data
+ 10);
1698 edt
.name
= bfd_get_32 (abfd
, data
+ 12);
1699 edt
.base
= bfd_get_32 (abfd
, data
+ 16);
1700 edt
.num_functions
= bfd_get_32 (abfd
, data
+ 20);
1701 edt
.num_names
= bfd_get_32 (abfd
, data
+ 24);
1702 edt
.eat_addr
= bfd_get_32 (abfd
, data
+ 28);
1703 edt
.npt_addr
= bfd_get_32 (abfd
, data
+ 32);
1704 edt
.ot_addr
= bfd_get_32 (abfd
, data
+ 36);
1706 adj
= section
->vma
- extra
->ImageBase
+ dataoff
;
1708 /* Dump the EDT first. */
1710 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1714 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt
.export_flags
);
1717 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt
.time_stamp
);
1720 /* xgettext:c-format */
1721 _("Major/Minor \t\t\t%d/%d\n"), edt
.major_ver
, edt
.minor_ver
);
1724 _("Name \t\t\t\t"));
1725 bfd_fprintf_vma (abfd
, file
, edt
.name
);
1727 if ((edt
.name
>= adj
) && (edt
.name
< adj
+ datasize
))
1728 fprintf (file
, " %.*s\n",
1729 (int) (datasize
- (edt
.name
- adj
)),
1730 data
+ edt
.name
- adj
);
1732 fprintf (file
, "(outside .edata section)\n");
1735 _("Ordinal Base \t\t\t%ld\n"), edt
.base
);
1741 _("\tExport Address Table \t\t%08lx\n"),
1745 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt
.num_names
);
1748 _("Table Addresses\n"));
1751 _("\tExport Address Table \t\t"));
1752 bfd_fprintf_vma (abfd
, file
, edt
.eat_addr
);
1753 fprintf (file
, "\n");
1756 _("\tName Pointer Table \t\t"));
1757 bfd_fprintf_vma (abfd
, file
, edt
.npt_addr
);
1758 fprintf (file
, "\n");
1761 _("\tOrdinal Table \t\t\t"));
1762 bfd_fprintf_vma (abfd
, file
, edt
.ot_addr
);
1763 fprintf (file
, "\n");
1765 /* The next table to find is the Export Address Table. It's basically
1766 a list of pointers that either locate a function in this dll, or
1767 forward the call to another dll. Something like:
1772 } export_address_table_entry; */
1775 _("\nExport Address Table -- Ordinal Base %ld\n"),
1778 /* PR 17512: Handle corrupt PE binaries. */
1779 /* PR 17512 file: 140-165018-0.004. */
1780 if (edt
.eat_addr
- adj
>= datasize
1781 /* PR 17512: file: 092b1829 */
1782 || (edt
.num_functions
+ 1) * 4 < edt
.num_functions
1783 || edt
.eat_addr
- adj
+ (edt
.num_functions
+ 1) * 4 > datasize
)
1784 fprintf (file
, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1785 (long) edt
.eat_addr
,
1786 (long) edt
.num_functions
);
1787 else for (i
= 0; i
< edt
.num_functions
; ++i
)
1789 bfd_vma eat_member
= bfd_get_32 (abfd
,
1790 data
+ edt
.eat_addr
+ (i
* 4) - adj
);
1791 if (eat_member
== 0)
1794 if (eat_member
- adj
<= datasize
)
1796 /* This rva is to a name (forwarding function) in our section. */
1797 /* Should locate a function descriptor. */
1799 "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1801 (long) (i
+ edt
.base
),
1802 (unsigned long) eat_member
,
1804 (int)(datasize
- (eat_member
- adj
)),
1805 data
+ eat_member
- adj
);
1809 /* Should locate a function descriptor in the reldata section. */
1811 "\t[%4ld] +base[%4ld] %04lx %s\n",
1813 (long) (i
+ edt
.base
),
1814 (unsigned long) eat_member
,
1819 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1820 /* Dump them in parallel for clarity. */
1822 _("\n[Ordinal/Name Pointer] Table\n"));
1824 /* PR 17512: Handle corrupt PE binaries. */
1825 if (edt
.npt_addr
+ (edt
.num_names
* 4) - adj
>= datasize
1826 /* PR 17512: file: bb68816e. */
1827 || edt
.num_names
* 4 < edt
.num_names
1828 || (data
+ edt
.npt_addr
- adj
) < data
)
1829 /* xgettext:c-format */
1830 fprintf (file
, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1831 (long) edt
.npt_addr
,
1832 (long) edt
.num_names
);
1833 /* PR 17512: file: 140-147171-0.004. */
1834 else if (edt
.ot_addr
+ (edt
.num_names
* 2) - adj
>= datasize
1835 || data
+ edt
.ot_addr
- adj
< data
)
1836 /* xgettext:c-format */
1837 fprintf (file
, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1839 (long) edt
.num_names
);
1840 else for (i
= 0; i
< edt
.num_names
; ++i
)
1845 ord
= bfd_get_16 (abfd
, data
+ edt
.ot_addr
+ (i
* 2) - adj
);
1846 name_ptr
= bfd_get_32 (abfd
, data
+ edt
.npt_addr
+ (i
* 4) - adj
);
1848 if ((name_ptr
- adj
) >= datasize
)
1850 /* xgettext:c-format */
1851 fprintf (file
, _("\t[%4ld] <corrupt offset: %lx>\n"),
1852 (long) ord
, (long) name_ptr
);
1856 char * name
= (char *) data
+ name_ptr
- adj
;
1858 fprintf (file
, "\t[%4ld] %.*s\n", (long) ord
,
1859 (int)((char *)(data
+ datasize
) - name
), name
);
1868 /* This really is architecture dependent. On IA-64, a .pdata entry
1869 consists of three dwords containing relative virtual addresses that
1870 specify the start and end address of the code range the entry
1871 covers and the address of the corresponding unwind info data.
1873 On ARM and SH-4, a compressed PDATA structure is used :
1874 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1875 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1876 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1878 This is the version for uncompressed data. */
1881 pe_print_pdata (bfd
* abfd
, void * vfile
)
1883 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1884 # define PDATA_ROW_SIZE (3 * 8)
1886 # define PDATA_ROW_SIZE (5 * 4)
1888 FILE *file
= (FILE *) vfile
;
1890 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1891 bfd_size_type datasize
= 0;
1893 bfd_size_type start
, stop
;
1894 int onaline
= PDATA_ROW_SIZE
;
1897 || coff_section_data (abfd
, section
) == NULL
1898 || pei_section_data (abfd
, section
) == NULL
)
1901 stop
= pei_section_data (abfd
, section
)->virt_size
;
1902 if ((stop
% onaline
) != 0)
1904 /* xgettext:c-format */
1905 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
1906 (long) stop
, onaline
);
1909 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1910 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1912 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1915 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1916 \t\tAddress Address Handler Data Address Mask\n"));
1919 datasize
= section
->size
;
1923 /* PR 17512: file: 002-193900-0.004. */
1924 if (datasize
< stop
)
1926 /* xgettext:c-format */
1927 fprintf (file
, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"),
1928 (long) stop
, (long) datasize
);
1932 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
1940 for (i
= start
; i
< stop
; i
+= onaline
)
1946 bfd_vma prolog_end_addr
;
1947 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1951 if (i
+ PDATA_ROW_SIZE
> stop
)
1954 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
1955 end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
1956 eh_handler
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 8);
1957 eh_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 12);
1958 prolog_end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 16);
1960 if (begin_addr
== 0 && end_addr
== 0 && eh_handler
== 0
1961 && eh_data
== 0 && prolog_end_addr
== 0)
1962 /* We are probably into the padding of the section now. */
1965 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1966 em_data
= ((eh_handler
& 0x1) << 2) | (prolog_end_addr
& 0x3);
1968 eh_handler
&= ~(bfd_vma
) 0x3;
1969 prolog_end_addr
&= ~(bfd_vma
) 0x3;
1972 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
1973 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
1974 bfd_fprintf_vma (abfd
, file
, end_addr
); fputc (' ', file
);
1975 bfd_fprintf_vma (abfd
, file
, eh_handler
);
1976 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1978 bfd_fprintf_vma (abfd
, file
, eh_data
); fputc (' ', file
);
1979 bfd_fprintf_vma (abfd
, file
, prolog_end_addr
);
1980 fprintf (file
, " %x", em_data
);
1983 #ifdef POWERPC_LE_PE
1984 if (eh_handler
== 0 && eh_data
!= 0)
1986 /* Special bits here, although the meaning may be a little
1987 mysterious. The only one I know for sure is 0x03
1990 0x01 Register Save Millicode
1991 0x02 Register Restore Millicode
1992 0x03 Glue Code Sequence. */
1996 fprintf (file
, _(" Register save millicode"));
1999 fprintf (file
, _(" Register restore millicode"));
2002 fprintf (file
, _(" Glue code sequence"));
2009 fprintf (file
, "\n");
2015 #undef PDATA_ROW_SIZE
2018 typedef struct sym_cache
2025 slurp_symtab (bfd
*abfd
, sym_cache
*psc
)
2027 asymbol
** sy
= NULL
;
2030 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
2036 storage
= bfd_get_symtab_upper_bound (abfd
);
2041 sy
= (asymbol
**) bfd_malloc (storage
);
2046 psc
->symcount
= bfd_canonicalize_symtab (abfd
, sy
);
2047 if (psc
->symcount
< 0)
2053 my_symbol_for_address (bfd
*abfd
, bfd_vma func
, sym_cache
*psc
)
2058 psc
->syms
= slurp_symtab (abfd
, psc
);
2060 for (i
= 0; i
< psc
->symcount
; i
++)
2062 if (psc
->syms
[i
]->section
->vma
+ psc
->syms
[i
]->value
== func
)
2063 return psc
->syms
[i
]->name
;
2070 cleanup_syms (sym_cache
*psc
)
2077 /* This is the version for "compressed" pdata. */
2080 _bfd_XX_print_ce_compressed_pdata (bfd
* abfd
, void * vfile
)
2082 # define PDATA_ROW_SIZE (2 * 4)
2083 FILE *file
= (FILE *) vfile
;
2084 bfd_byte
*data
= NULL
;
2085 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
2086 bfd_size_type datasize
= 0;
2088 bfd_size_type start
, stop
;
2089 int onaline
= PDATA_ROW_SIZE
;
2090 struct sym_cache cache
= {0, 0} ;
2093 || coff_section_data (abfd
, section
) == NULL
2094 || pei_section_data (abfd
, section
) == NULL
)
2097 stop
= pei_section_data (abfd
, section
)->virt_size
;
2098 if ((stop
% onaline
) != 0)
2100 /* xgettext:c-format */
2101 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
2102 (long) stop
, onaline
);
2105 _("\nThe Function Table (interpreted .pdata section contents)\n"));
2108 vma:\t\tBegin Prolog Function Flags Exception EH\n\
2109 \t\tAddress Length Length 32b exc Handler Data\n"));
2111 datasize
= section
->size
;
2115 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2123 for (i
= start
; i
< stop
; i
+= onaline
)
2127 bfd_vma prolog_length
, function_length
;
2128 int flag32bit
, exception_flag
;
2131 if (i
+ PDATA_ROW_SIZE
> stop
)
2134 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
2135 other_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
2137 if (begin_addr
== 0 && other_data
== 0)
2138 /* We are probably into the padding of the section now. */
2141 prolog_length
= (other_data
& 0x000000FF);
2142 function_length
= (other_data
& 0x3FFFFF00) >> 8;
2143 flag32bit
= (int)((other_data
& 0x40000000) >> 30);
2144 exception_flag
= (int)((other_data
& 0x80000000) >> 31);
2147 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
2148 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
2149 bfd_fprintf_vma (abfd
, file
, prolog_length
); fputc (' ', file
);
2150 bfd_fprintf_vma (abfd
, file
, function_length
); fputc (' ', file
);
2151 fprintf (file
, "%2d %2d ", flag32bit
, exception_flag
);
2153 /* Get the exception handler's address and the data passed from the
2154 .text section. This is really the data that belongs with the .pdata
2155 but got "compressed" out for the ARM and SH4 architectures. */
2156 tsection
= bfd_get_section_by_name (abfd
, ".text");
2157 if (tsection
&& coff_section_data (abfd
, tsection
)
2158 && pei_section_data (abfd
, tsection
))
2160 bfd_vma eh_off
= (begin_addr
- 8) - tsection
->vma
;
2163 tdata
= (bfd_byte
*) bfd_malloc (8);
2166 if (bfd_get_section_contents (abfd
, tsection
, tdata
, eh_off
, 8))
2168 bfd_vma eh
, eh_data
;
2170 eh
= bfd_get_32 (abfd
, tdata
);
2171 eh_data
= bfd_get_32 (abfd
, tdata
+ 4);
2172 fprintf (file
, "%08x ", (unsigned int) eh
);
2173 fprintf (file
, "%08x", (unsigned int) eh_data
);
2176 const char *s
= my_symbol_for_address (abfd
, eh
, &cache
);
2179 fprintf (file
, " (%s) ", s
);
2186 fprintf (file
, "\n");
2191 cleanup_syms (& cache
);
2194 #undef PDATA_ROW_SIZE
2198 #define IMAGE_REL_BASED_HIGHADJ 4
2199 static const char * const tbl
[] =
2213 "UNKNOWN", /* MUST be last. */
2217 pe_print_reloc (bfd
* abfd
, void * vfile
)
2219 FILE *file
= (FILE *) vfile
;
2221 asection
*section
= bfd_get_section_by_name (abfd
, ".reloc");
2224 if (section
== NULL
|| section
->size
== 0 || !(section
->flags
& SEC_HAS_CONTENTS
))
2228 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2230 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2237 end
= data
+ section
->size
;
2238 while (p
+ 8 <= end
)
2241 bfd_vma virtual_address
;
2242 unsigned long number
, size
;
2243 bfd_byte
*chunk_end
;
2245 /* The .reloc section is a sequence of blocks, with a header consisting
2246 of two 32 bit quantities, followed by a number of 16 bit entries. */
2247 virtual_address
= bfd_get_32 (abfd
, p
);
2248 size
= bfd_get_32 (abfd
, p
+ 4);
2250 number
= (size
- 8) / 2;
2256 /* xgettext:c-format */
2257 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2258 (unsigned long) virtual_address
, size
, size
, number
);
2260 chunk_end
= p
- 8 + size
;
2261 if (chunk_end
> end
)
2264 while (p
+ 2 <= chunk_end
)
2266 unsigned short e
= bfd_get_16 (abfd
, p
);
2267 unsigned int t
= (e
& 0xF000) >> 12;
2268 int off
= e
& 0x0FFF;
2270 if (t
>= sizeof (tbl
) / sizeof (tbl
[0]))
2271 t
= (sizeof (tbl
) / sizeof (tbl
[0])) - 1;
2274 /* xgettext:c-format */
2275 _("\treloc %4d offset %4x [%4lx] %s"),
2276 j
, off
, (unsigned long) (off
+ virtual_address
), tbl
[t
]);
2281 /* HIGHADJ takes an argument, - the next record *is* the
2282 low 16 bits of addend. */
2283 if (t
== IMAGE_REL_BASED_HIGHADJ
&& p
+ 2 <= chunk_end
)
2285 fprintf (file
, " (%4x)", (unsigned int) bfd_get_16 (abfd
, p
));
2290 fprintf (file
, "\n");
2299 /* A data structure describing the regions of a .rsrc section.
2300 Some fields are filled in as the section is parsed. */
2302 typedef struct rsrc_regions
2304 bfd_byte
* section_start
;
2305 bfd_byte
* section_end
;
2306 bfd_byte
* strings_start
;
2307 bfd_byte
* resource_start
;
2311 rsrc_print_resource_directory (FILE * , bfd
*, unsigned int, bfd_byte
*,
2312 rsrc_regions
*, bfd_vma
);
2314 /* Print the resource entry at DATA, with the text indented by INDENT.
2315 Recusively calls rsrc_print_resource_directory to print the contents
2316 of directory entries.
2317 Returns the address of the end of the data associated with the entry
2318 or section_end + 1 upon failure. */
2321 rsrc_print_resource_entries (FILE * file
,
2323 unsigned int indent
,
2324 bfd_boolean is_name
,
2326 rsrc_regions
* regions
,
2329 unsigned long entry
, addr
, size
;
2332 if (data
+ 8 >= regions
->section_end
)
2333 return regions
->section_end
+ 1;
2335 /* xgettext:c-format */
2336 fprintf (file
, _("%03x %*.s Entry: "), (int)(data
- regions
->section_start
), indent
, " ");
2338 entry
= (unsigned long) bfd_get_32 (abfd
, data
);
2343 /* Note - the documentation says that this field is an RVA value
2344 but windres appears to produce a section relative offset with
2345 the top bit set. Support both styles for now. */
2346 if (HighBitSet (entry
))
2347 name
= regions
->section_start
+ WithoutHighBit (entry
);
2349 name
= regions
->section_start
+ entry
- rva_bias
;
2351 if (name
+ 2 < regions
->section_end
&& name
> regions
->section_start
)
2355 if (regions
->strings_start
== NULL
)
2356 regions
->strings_start
= name
;
2358 len
= bfd_get_16 (abfd
, name
);
2360 fprintf (file
, _("name: [val: %08lx len %d]: "), entry
, len
);
2362 if (name
+ 2 + len
* 2 < regions
->section_end
)
2364 /* This strange loop is to cope with multibyte characters. */
2371 /* Avoid printing control characters. */
2372 if (c
> 0 && c
< 32)
2373 fprintf (file
, "^%c", c
+ 64);
2375 fprintf (file
, "%.1s", name
);
2380 fprintf (file
, _("<corrupt string length: %#x>\n"), len
);
2381 /* PR binutils/17512: Do not try to continue decoding a
2382 corrupted resource section. It is likely to end up with
2383 reams of extraneous output. FIXME: We could probably
2384 continue if we disable the printing of strings... */
2385 return regions
->section_end
+ 1;
2390 fprintf (file
, _("<corrupt string offset: %#lx>\n"), entry
);
2391 return regions
->section_end
+ 1;
2395 fprintf (file
, _("ID: %#08lx"), entry
);
2397 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
2398 fprintf (file
, _(", Value: %#08lx\n"), entry
);
2400 if (HighBitSet (entry
))
2402 data
= regions
->section_start
+ WithoutHighBit (entry
);
2403 if (data
<= regions
->section_start
|| data
> regions
->section_end
)
2404 return regions
->section_end
+ 1;
2406 /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2407 in the resource table. We need some way to detect this. */
2408 return rsrc_print_resource_directory (file
, abfd
, indent
+ 1, data
,
2412 leaf
= regions
->section_start
+ entry
;
2414 if (leaf
+ 16 >= regions
->section_end
2415 /* PR 17512: file: 055dff7e. */
2416 || leaf
< regions
->section_start
)
2417 return regions
->section_end
+ 1;
2419 /* xgettext:c-format */
2420 fprintf (file
, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2421 (int) (entry
), indent
, " ",
2422 addr
= (long) bfd_get_32 (abfd
, leaf
),
2423 size
= (long) bfd_get_32 (abfd
, leaf
+ 4),
2424 (int) bfd_get_32 (abfd
, leaf
+ 8));
2426 /* Check that the reserved entry is 0. */
2427 if (bfd_get_32 (abfd
, leaf
+ 12) != 0
2428 /* And that the data address/size is valid too. */
2429 || (regions
->section_start
+ (addr
- rva_bias
) + size
> regions
->section_end
))
2430 return regions
->section_end
+ 1;
2432 if (regions
->resource_start
== NULL
)
2433 regions
->resource_start
= regions
->section_start
+ (addr
- rva_bias
);
2435 return regions
->section_start
+ (addr
- rva_bias
) + size
;
2438 #define max(a,b) ((a) > (b) ? (a) : (b))
2439 #define min(a,b) ((a) < (b) ? (a) : (b))
2442 rsrc_print_resource_directory (FILE * file
,
2444 unsigned int indent
,
2446 rsrc_regions
* regions
,
2449 unsigned int num_names
, num_ids
;
2450 bfd_byte
* highest_data
= data
;
2452 if (data
+ 16 >= regions
->section_end
)
2453 return regions
->section_end
+ 1;
2455 fprintf (file
, "%03x %*.s ", (int)(data
- regions
->section_start
), indent
, " ");
2458 case 0: fprintf (file
, "Type"); break;
2459 case 2: fprintf (file
, "Name"); break;
2460 case 4: fprintf (file
, "Language"); break;
2462 fprintf (file
, _("<unknown directory type: %d>\n"), indent
);
2463 /* FIXME: For now we end the printing here. If in the
2464 future more directory types are added to the RSRC spec
2465 then we will need to change this. */
2466 return regions
->section_end
+ 1;
2469 /* xgettext:c-format */
2470 fprintf (file
, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2471 (int) bfd_get_32 (abfd
, data
),
2472 (long) bfd_get_32 (abfd
, data
+ 4),
2473 (int) bfd_get_16 (abfd
, data
+ 8),
2474 (int) bfd_get_16 (abfd
, data
+ 10),
2475 num_names
= (int) bfd_get_16 (abfd
, data
+ 12),
2476 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14));
2479 while (num_names
--)
2481 bfd_byte
* entry_end
;
2483 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, TRUE
,
2484 data
, regions
, rva_bias
);
2486 highest_data
= max (highest_data
, entry_end
);
2487 if (entry_end
>= regions
->section_end
)
2493 bfd_byte
* entry_end
;
2495 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, FALSE
,
2496 data
, regions
, rva_bias
);
2498 highest_data
= max (highest_data
, entry_end
);
2499 if (entry_end
>= regions
->section_end
)
2503 return max (highest_data
, data
);
2506 /* Display the contents of a .rsrc section. We do not try to
2507 reproduce the resources, windres does that. Instead we dump
2508 the tables in a human readable format. */
2511 rsrc_print_section (bfd
* abfd
, void * vfile
)
2515 FILE * file
= (FILE *) vfile
;
2516 bfd_size_type datasize
;
2519 rsrc_regions regions
;
2521 pe
= pe_data (abfd
);
2525 section
= bfd_get_section_by_name (abfd
, ".rsrc");
2526 if (section
== NULL
)
2528 if (!(section
->flags
& SEC_HAS_CONTENTS
))
2531 datasize
= section
->size
;
2535 rva_bias
= section
->vma
- pe
->pe_opthdr
.ImageBase
;
2537 if (! bfd_malloc_and_get_section (abfd
, section
, & data
))
2543 regions
.section_start
= data
;
2544 regions
.section_end
= data
+ datasize
;
2545 regions
.strings_start
= NULL
;
2546 regions
.resource_start
= NULL
;
2549 fprintf (file
, "\nThe .rsrc Resource Directory section:\n");
2551 while (data
< regions
.section_end
)
2553 bfd_byte
* p
= data
;
2555 data
= rsrc_print_resource_directory (file
, abfd
, 0, data
, & regions
, rva_bias
);
2557 if (data
== regions
.section_end
+ 1)
2558 fprintf (file
, _("Corrupt .rsrc section detected!\n"));
2561 /* Align data before continuing. */
2562 int align
= (1 << section
->alignment_power
) - 1;
2564 data
= (bfd_byte
*) (((ptrdiff_t) (data
+ align
)) & ~ align
);
2565 rva_bias
+= data
- p
;
2567 /* For reasons that are unclear .rsrc sections are sometimes created
2568 aligned to a 1^3 boundary even when their alignment is set at
2569 1^2. Catch that case here before we issue a spurious warning
2571 if (data
== (regions
.section_end
- 4))
2572 data
= regions
.section_end
;
2573 else if (data
< regions
.section_end
)
2575 /* If the extra data is all zeros then do not complain.
2576 This is just padding so that the section meets the
2577 page size requirements. */
2578 while (++ data
< regions
.section_end
)
2581 if (data
< regions
.section_end
)
2582 fprintf (file
, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2587 if (regions
.strings_start
!= NULL
)
2588 fprintf (file
, _(" String table starts at offset: %#03x\n"),
2589 (int) (regions
.strings_start
- regions
.section_start
));
2590 if (regions
.resource_start
!= NULL
)
2591 fprintf (file
, _(" Resources start at offset: %#03x\n"),
2592 (int) (regions
.resource_start
- regions
.section_start
));
2594 free (regions
.section_start
);
2598 #define IMAGE_NUMBEROF_DEBUG_TYPES 17
2600 static char * debug_type_names
[IMAGE_NUMBEROF_DEBUG_TYPES
] =
2622 pe_print_debugdata (bfd
* abfd
, void * vfile
)
2624 FILE *file
= (FILE *) vfile
;
2625 pe_data_type
*pe
= pe_data (abfd
);
2626 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2629 bfd_size_type dataoff
;
2632 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2633 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2638 addr
+= extra
->ImageBase
;
2639 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2641 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2645 if (section
== NULL
)
2648 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2651 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
2654 _("\nThere is a debug directory in %s, but that section has no contents\n"),
2658 else if (section
->size
< size
)
2661 _("\nError: section %s contains the debug data starting address but it is too small\n"),
2666 fprintf (file
, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2667 section
->name
, (unsigned long) addr
);
2669 dataoff
= addr
- section
->vma
;
2671 if (size
> (section
->size
- dataoff
))
2673 fprintf (file
, _("The debug data size field in the data directory is too big for the section"));
2678 _("Type Size Rva Offset\n"));
2680 /* Read the whole section. */
2681 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2687 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2689 const char *type_name
;
2690 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2691 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2692 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2694 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2696 if ((idd
.Type
) >= IMAGE_NUMBEROF_DEBUG_TYPES
)
2697 type_name
= debug_type_names
[0];
2699 type_name
= debug_type_names
[idd
.Type
];
2701 fprintf (file
, " %2ld %14s %08lx %08lx %08lx\n",
2702 idd
.Type
, type_name
, idd
.SizeOfData
,
2703 idd
.AddressOfRawData
, idd
.PointerToRawData
);
2705 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_CODEVIEW
)
2707 char signature
[CV_INFO_SIGNATURE_LENGTH
* 2 + 1];
2708 /* PR 17512: file: 065-29434-0.001:0.1
2709 We need to use a 32-bit aligned buffer
2710 to safely read in a codeview record. */
2711 char buffer
[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO
);
2713 CODEVIEW_INFO
*cvinfo
= (CODEVIEW_INFO
*) buffer
;
2715 /* The debug entry doesn't have to have to be in a section,
2716 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2717 if (!_bfd_XXi_slurp_codeview_record (abfd
, (file_ptr
) idd
.PointerToRawData
,
2718 idd
.SizeOfData
, cvinfo
))
2721 for (j
= 0; j
< cvinfo
->SignatureLength
; j
++)
2722 sprintf (&signature
[j
*2], "%02x", cvinfo
->Signature
[j
] & 0xff);
2724 /* xgettext:c-format */
2725 fprintf (file
, _("(format %c%c%c%c signature %s age %ld)\n"),
2726 buffer
[0], buffer
[1], buffer
[2], buffer
[3],
2727 signature
, cvinfo
->Age
);
2733 if (size
% sizeof (struct external_IMAGE_DEBUG_DIRECTORY
) != 0)
2735 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2741 pe_is_repro (bfd
* abfd
)
2743 pe_data_type
*pe
= pe_data (abfd
);
2744 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2747 bfd_size_type dataoff
;
2749 bfd_boolean res
= FALSE
;
2751 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2752 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2757 addr
+= extra
->ImageBase
;
2758 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2760 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2764 if ((section
== NULL
)
2765 || (!(section
->flags
& SEC_HAS_CONTENTS
))
2766 || (section
->size
< size
))
2771 dataoff
= addr
- section
->vma
;
2773 if (size
> (section
->size
- dataoff
))
2778 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2784 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2786 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2787 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2788 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2790 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2792 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_REPRO
)
2804 /* Print out the program headers. */
2807 _bfd_XX_print_private_bfd_data_common (bfd
* abfd
, void * vfile
)
2809 FILE *file
= (FILE *) vfile
;
2811 pe_data_type
*pe
= pe_data (abfd
);
2812 struct internal_extra_pe_aouthdr
*i
= &pe
->pe_opthdr
;
2813 const char *subsystem_name
= NULL
;
2816 /* The MS dumpbin program reportedly ands with 0xff0f before
2817 printing the characteristics field. Not sure why. No reason to
2819 fprintf (file
, _("\nCharacteristics 0x%x\n"), pe
->real_flags
);
2821 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2822 PF (IMAGE_FILE_RELOCS_STRIPPED
, "relocations stripped");
2823 PF (IMAGE_FILE_EXECUTABLE_IMAGE
, "executable");
2824 PF (IMAGE_FILE_LINE_NUMS_STRIPPED
, "line numbers stripped");
2825 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED
, "symbols stripped");
2826 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE
, "large address aware");
2827 PF (IMAGE_FILE_BYTES_REVERSED_LO
, "little endian");
2828 PF (IMAGE_FILE_32BIT_MACHINE
, "32 bit words");
2829 PF (IMAGE_FILE_DEBUG_STRIPPED
, "debugging information removed");
2830 PF (IMAGE_FILE_SYSTEM
, "system file");
2831 PF (IMAGE_FILE_DLL
, "DLL");
2832 PF (IMAGE_FILE_BYTES_REVERSED_HI
, "big endian");
2836 If a PE_IMAGE_DEBUG_TYPE_REPRO entry is present in the debug directory, the
2837 timestamp is to be interpreted as the hash of a reproducible build.
2839 if (pe_is_repro (abfd
))
2841 fprintf (file
, "\nTime/Date\t\t%08lx", pe
->coff
.timestamp
);
2842 fprintf (file
, "\t(This is a reproducible build file hash, not a timestamp)\n");
2846 /* ctime implies '\n'. */
2847 time_t t
= pe
->coff
.timestamp
;
2848 fprintf (file
, "\nTime/Date\t\t%s", ctime (&t
));
2851 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2852 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2854 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2855 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2857 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2858 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2863 case IMAGE_NT_OPTIONAL_HDR_MAGIC
:
2866 case IMAGE_NT_OPTIONAL_HDR64_MAGIC
:
2869 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC
:
2876 fprintf (file
, "Magic\t\t\t%04x", i
->Magic
);
2878 fprintf (file
, "\t(%s)",name
);
2879 fprintf (file
, "\nMajorLinkerVersion\t%d\n", i
->MajorLinkerVersion
);
2880 fprintf (file
, "MinorLinkerVersion\t%d\n", i
->MinorLinkerVersion
);
2881 fprintf (file
, "SizeOfCode\t\t");
2882 bfd_fprintf_vma (abfd
, file
, i
->SizeOfCode
);
2883 fprintf (file
, "\nSizeOfInitializedData\t");
2884 bfd_fprintf_vma (abfd
, file
, i
->SizeOfInitializedData
);
2885 fprintf (file
, "\nSizeOfUninitializedData\t");
2886 bfd_fprintf_vma (abfd
, file
, i
->SizeOfUninitializedData
);
2887 fprintf (file
, "\nAddressOfEntryPoint\t");
2888 bfd_fprintf_vma (abfd
, file
, i
->AddressOfEntryPoint
);
2889 fprintf (file
, "\nBaseOfCode\t\t");
2890 bfd_fprintf_vma (abfd
, file
, i
->BaseOfCode
);
2891 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2892 /* PE32+ does not have BaseOfData member! */
2893 fprintf (file
, "\nBaseOfData\t\t");
2894 bfd_fprintf_vma (abfd
, file
, i
->BaseOfData
);
2897 fprintf (file
, "\nImageBase\t\t");
2898 bfd_fprintf_vma (abfd
, file
, i
->ImageBase
);
2899 fprintf (file
, "\nSectionAlignment\t%08x\n", i
->SectionAlignment
);
2900 fprintf (file
, "FileAlignment\t\t%08x\n", i
->FileAlignment
);
2901 fprintf (file
, "MajorOSystemVersion\t%d\n", i
->MajorOperatingSystemVersion
);
2902 fprintf (file
, "MinorOSystemVersion\t%d\n", i
->MinorOperatingSystemVersion
);
2903 fprintf (file
, "MajorImageVersion\t%d\n", i
->MajorImageVersion
);
2904 fprintf (file
, "MinorImageVersion\t%d\n", i
->MinorImageVersion
);
2905 fprintf (file
, "MajorSubsystemVersion\t%d\n", i
->MajorSubsystemVersion
);
2906 fprintf (file
, "MinorSubsystemVersion\t%d\n", i
->MinorSubsystemVersion
);
2907 fprintf (file
, "Win32Version\t\t%08x\n", i
->Reserved1
);
2908 fprintf (file
, "SizeOfImage\t\t%08x\n", i
->SizeOfImage
);
2909 fprintf (file
, "SizeOfHeaders\t\t%08x\n", i
->SizeOfHeaders
);
2910 fprintf (file
, "CheckSum\t\t%08x\n", i
->CheckSum
);
2912 switch (i
->Subsystem
)
2914 case IMAGE_SUBSYSTEM_UNKNOWN
:
2915 subsystem_name
= "unspecified";
2917 case IMAGE_SUBSYSTEM_NATIVE
:
2918 subsystem_name
= "NT native";
2920 case IMAGE_SUBSYSTEM_WINDOWS_GUI
:
2921 subsystem_name
= "Windows GUI";
2923 case IMAGE_SUBSYSTEM_WINDOWS_CUI
:
2924 subsystem_name
= "Windows CUI";
2926 case IMAGE_SUBSYSTEM_POSIX_CUI
:
2927 subsystem_name
= "POSIX CUI";
2929 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI
:
2930 subsystem_name
= "Wince CUI";
2932 // These are from UEFI Platform Initialization Specification 1.1.
2933 case IMAGE_SUBSYSTEM_EFI_APPLICATION
:
2934 subsystem_name
= "EFI application";
2936 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
:
2937 subsystem_name
= "EFI boot service driver";
2939 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
:
2940 subsystem_name
= "EFI runtime driver";
2942 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER
:
2943 subsystem_name
= "SAL runtime driver";
2945 // This is from revision 8.0 of the MS PE/COFF spec
2946 case IMAGE_SUBSYSTEM_XBOX
:
2947 subsystem_name
= "XBOX";
2949 // Added default case for clarity - subsystem_name is NULL anyway.
2951 subsystem_name
= NULL
;
2954 fprintf (file
, "Subsystem\t\t%08x", i
->Subsystem
);
2956 fprintf (file
, "\t(%s)", subsystem_name
);
2957 fprintf (file
, "\nDllCharacteristics\t%08x\n", i
->DllCharacteristics
);
2958 fprintf (file
, "SizeOfStackReserve\t");
2959 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackReserve
);
2960 fprintf (file
, "\nSizeOfStackCommit\t");
2961 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackCommit
);
2962 fprintf (file
, "\nSizeOfHeapReserve\t");
2963 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapReserve
);
2964 fprintf (file
, "\nSizeOfHeapCommit\t");
2965 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapCommit
);
2966 fprintf (file
, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i
->LoaderFlags
);
2967 fprintf (file
, "NumberOfRvaAndSizes\t%08lx\n",
2968 (unsigned long) i
->NumberOfRvaAndSizes
);
2970 fprintf (file
, "\nThe Data Directory\n");
2971 for (j
= 0; j
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; j
++)
2973 fprintf (file
, "Entry %1x ", j
);
2974 bfd_fprintf_vma (abfd
, file
, i
->DataDirectory
[j
].VirtualAddress
);
2975 fprintf (file
, " %08lx ", (unsigned long) i
->DataDirectory
[j
].Size
);
2976 fprintf (file
, "%s\n", dir_names
[j
]);
2979 pe_print_idata (abfd
, vfile
);
2980 pe_print_edata (abfd
, vfile
);
2981 if (bfd_coff_have_print_pdata (abfd
))
2982 bfd_coff_print_pdata (abfd
, vfile
);
2984 pe_print_pdata (abfd
, vfile
);
2985 pe_print_reloc (abfd
, vfile
);
2986 pe_print_debugdata (abfd
, file
);
2988 rsrc_print_section (abfd
, vfile
);
2994 is_vma_in_section (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sect
, void *obj
)
2996 bfd_vma addr
= * (bfd_vma
*) obj
;
2997 return (addr
>= sect
->vma
) && (addr
< (sect
->vma
+ sect
->size
));
3001 find_section_by_vma (bfd
*abfd
, bfd_vma addr
)
3003 return bfd_sections_find_if (abfd
, is_vma_in_section
, (void *) & addr
);
3006 /* Copy any private info we understand from the input bfd
3007 to the output bfd. */
3010 _bfd_XX_bfd_copy_private_bfd_data_common (bfd
* ibfd
, bfd
* obfd
)
3012 pe_data_type
*ipe
, *ope
;
3014 /* One day we may try to grok other private data. */
3015 if (ibfd
->xvec
->flavour
!= bfd_target_coff_flavour
3016 || obfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
3019 ipe
= pe_data (ibfd
);
3020 ope
= pe_data (obfd
);
3022 /* pe_opthdr is copied in copy_object. */
3023 ope
->dll
= ipe
->dll
;
3025 /* Don't copy input subsystem if output is different from input. */
3026 if (obfd
->xvec
!= ibfd
->xvec
)
3027 ope
->pe_opthdr
.Subsystem
= IMAGE_SUBSYSTEM_UNKNOWN
;
3029 /* For strip: if we removed .reloc, we'll make a real mess of things
3030 if we don't remove this entry as well. */
3031 if (! pe_data (obfd
)->has_reloc_section
)
3033 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].VirtualAddress
= 0;
3034 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].Size
= 0;
3037 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
3038 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
3040 if (! pe_data (ibfd
)->has_reloc_section
3041 && ! (pe_data (ibfd
)->real_flags
& IMAGE_FILE_RELOCS_STRIPPED
))
3042 pe_data (obfd
)->dont_strip_reloc
= 1;
3044 memcpy (ope
->dos_message
, ipe
->dos_message
, sizeof (ope
->dos_message
));
3046 /* The file offsets contained in the debug directory need rewriting. */
3047 if (ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
!= 0)
3049 bfd_vma addr
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
3050 + ope
->pe_opthdr
.ImageBase
;
3051 asection
*section
= find_section_by_vma (obfd
, addr
);
3054 if (section
&& bfd_malloc_and_get_section (obfd
, section
, &data
))
3057 struct external_IMAGE_DEBUG_DIRECTORY
*dd
=
3058 (struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ (addr
- section
->vma
));
3060 /* PR 17512: file: 0f15796a. */
3061 if ((unsigned long) ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
3062 > section
->size
- (addr
- section
->vma
))
3064 /* xgettext:c-format */
3066 (_("%pB: Data Directory size (%lx) "
3067 "exceeds space left in section (%" PRIx64
")"),
3068 obfd
, ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
,
3069 (uint64_t) (section
->size
- (addr
- section
->vma
)));
3074 for (i
= 0; i
< ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
3075 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
3077 asection
*ddsection
;
3078 struct external_IMAGE_DEBUG_DIRECTORY
*edd
= &(dd
[i
]);
3079 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
3081 _bfd_XXi_swap_debugdir_in (obfd
, edd
, &idd
);
3083 if (idd
.AddressOfRawData
== 0)
3084 continue; /* RVA 0 means only offset is valid, not handled yet. */
3086 ddsection
= find_section_by_vma (obfd
, idd
.AddressOfRawData
+ ope
->pe_opthdr
.ImageBase
);
3088 continue; /* Not in a section! */
3090 idd
.PointerToRawData
= ddsection
->filepos
+ (idd
.AddressOfRawData
3091 + ope
->pe_opthdr
.ImageBase
) - ddsection
->vma
;
3093 _bfd_XXi_swap_debugdir_out (obfd
, &idd
, edd
);
3096 if (!bfd_set_section_contents (obfd
, section
, data
, 0, section
->size
))
3098 _bfd_error_handler (_("failed to update file offsets in debug directory"));
3106 _bfd_error_handler (_("%pB: failed to read debug data section"), obfd
);
3114 /* Copy private section data. */
3117 _bfd_XX_bfd_copy_private_section_data (bfd
*ibfd
,
3122 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
3123 || bfd_get_flavour (obfd
) != bfd_target_coff_flavour
)
3126 if (coff_section_data (ibfd
, isec
) != NULL
3127 && pei_section_data (ibfd
, isec
) != NULL
)
3129 if (coff_section_data (obfd
, osec
) == NULL
)
3131 size_t amt
= sizeof (struct coff_section_tdata
);
3132 osec
->used_by_bfd
= bfd_zalloc (obfd
, amt
);
3133 if (osec
->used_by_bfd
== NULL
)
3137 if (pei_section_data (obfd
, osec
) == NULL
)
3139 size_t amt
= sizeof (struct pei_section_tdata
);
3140 coff_section_data (obfd
, osec
)->tdata
= bfd_zalloc (obfd
, amt
);
3141 if (coff_section_data (obfd
, osec
)->tdata
== NULL
)
3145 pei_section_data (obfd
, osec
)->virt_size
=
3146 pei_section_data (ibfd
, isec
)->virt_size
;
3147 pei_section_data (obfd
, osec
)->pe_flags
=
3148 pei_section_data (ibfd
, isec
)->pe_flags
;
3155 _bfd_XX_get_symbol_info (bfd
* abfd
, asymbol
*symbol
, symbol_info
*ret
)
3157 coff_get_symbol_info (abfd
, symbol
, ret
);
3160 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
3162 sort_x64_pdata (const void *l
, const void *r
)
3164 const char *lp
= (const char *) l
;
3165 const char *rp
= (const char *) r
;
3167 vl
= bfd_getl32 (lp
); vr
= bfd_getl32 (rp
);
3169 return (vl
< vr
? -1 : 1);
3170 /* We compare just begin address. */
3175 /* Functions to process a .rsrc section. */
3177 static unsigned int sizeof_leaves
;
3178 static unsigned int sizeof_strings
;
3179 static unsigned int sizeof_tables_and_entries
;
3182 rsrc_count_directory (bfd
*, bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
3185 rsrc_count_entries (bfd
* abfd
,
3186 bfd_boolean is_name
,
3187 bfd_byte
* datastart
,
3192 unsigned long entry
, addr
, size
;
3194 if (data
+ 8 >= dataend
)
3201 entry
= (long) bfd_get_32 (abfd
, data
);
3203 if (HighBitSet (entry
))
3204 name
= datastart
+ WithoutHighBit (entry
);
3206 name
= datastart
+ entry
- rva_bias
;
3208 if (name
+ 2 >= dataend
|| name
< datastart
)
3211 unsigned int len
= bfd_get_16 (abfd
, name
);
3212 if (len
== 0 || len
> 256)
3216 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
3218 if (HighBitSet (entry
))
3220 data
= datastart
+ WithoutHighBit (entry
);
3222 if (data
<= datastart
|| data
>= dataend
)
3225 return rsrc_count_directory (abfd
, datastart
, data
, dataend
, rva_bias
);
3228 if (datastart
+ entry
+ 16 >= dataend
)
3231 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
);
3232 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4);
3234 return datastart
+ addr
- rva_bias
+ size
;
3238 rsrc_count_directory (bfd
* abfd
,
3239 bfd_byte
* datastart
,
3244 unsigned int num_entries
, num_ids
;
3245 bfd_byte
* highest_data
= data
;
3247 if (data
+ 16 >= dataend
)
3250 num_entries
= (int) bfd_get_16 (abfd
, data
+ 12);
3251 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14);
3253 num_entries
+= num_ids
;
3257 while (num_entries
--)
3259 bfd_byte
* entry_end
;
3261 entry_end
= rsrc_count_entries (abfd
, num_entries
>= num_ids
,
3262 datastart
, data
, dataend
, rva_bias
);
3264 highest_data
= max (highest_data
, entry_end
);
3265 if (entry_end
>= dataend
)
3269 return max (highest_data
, data
);
3272 typedef struct rsrc_dir_chain
3274 unsigned int num_entries
;
3275 struct rsrc_entry
* first_entry
;
3276 struct rsrc_entry
* last_entry
;
3279 typedef struct rsrc_directory
3281 unsigned int characteristics
;
3286 rsrc_dir_chain names
;
3289 struct rsrc_entry
* entry
;
3292 typedef struct rsrc_string
3298 typedef struct rsrc_leaf
3301 unsigned int codepage
;
3305 typedef struct rsrc_entry
3307 bfd_boolean is_name
;
3311 struct rsrc_string name
;
3317 struct rsrc_directory
* directory
;
3318 struct rsrc_leaf
* leaf
;
3321 struct rsrc_entry
* next_entry
;
3322 struct rsrc_directory
* parent
;
3326 rsrc_parse_directory (bfd
*, rsrc_directory
*, bfd_byte
*,
3327 bfd_byte
*, bfd_byte
*, bfd_vma
, rsrc_entry
*);
3330 rsrc_parse_entry (bfd
* abfd
,
3331 bfd_boolean is_name
,
3333 bfd_byte
* datastart
,
3337 rsrc_directory
* parent
)
3339 unsigned long val
, addr
, size
;
3341 val
= bfd_get_32 (abfd
, data
);
3343 entry
->parent
= parent
;
3344 entry
->is_name
= is_name
;
3350 if (HighBitSet (val
))
3352 val
= WithoutHighBit (val
);
3354 address
= datastart
+ val
;
3358 address
= datastart
+ val
- rva_bias
;
3361 if (address
+ 3 > dataend
)
3364 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, address
);
3365 entry
->name_id
.name
.string
= address
+ 2;
3368 entry
->name_id
.id
= val
;
3370 val
= bfd_get_32 (abfd
, data
+ 4);
3372 if (HighBitSet (val
))
3374 entry
->is_dir
= TRUE
;
3375 entry
->value
.directory
= bfd_malloc (sizeof * entry
->value
.directory
);
3376 if (entry
->value
.directory
== NULL
)
3379 return rsrc_parse_directory (abfd
, entry
->value
.directory
,
3381 datastart
+ WithoutHighBit (val
),
3382 dataend
, rva_bias
, entry
);
3385 entry
->is_dir
= FALSE
;
3386 entry
->value
.leaf
= bfd_malloc (sizeof * entry
->value
.leaf
);
3387 if (entry
->value
.leaf
== NULL
)
3390 data
= datastart
+ val
;
3391 if (data
< datastart
|| data
>= dataend
)
3394 addr
= bfd_get_32 (abfd
, data
);
3395 size
= entry
->value
.leaf
->size
= bfd_get_32 (abfd
, data
+ 4);
3396 entry
->value
.leaf
->codepage
= bfd_get_32 (abfd
, data
+ 8);
3397 /* FIXME: We assume that the reserved field (data + 12) is OK. */
3399 entry
->value
.leaf
->data
= bfd_malloc (size
);
3400 if (entry
->value
.leaf
->data
== NULL
)
3403 memcpy (entry
->value
.leaf
->data
, datastart
+ addr
- rva_bias
, size
);
3404 return datastart
+ (addr
- rva_bias
) + size
;
3408 rsrc_parse_entries (bfd
* abfd
,
3409 rsrc_dir_chain
* chain
,
3410 bfd_boolean is_name
,
3411 bfd_byte
* highest_data
,
3412 bfd_byte
* datastart
,
3416 rsrc_directory
* parent
)
3421 if (chain
->num_entries
== 0)
3423 chain
->first_entry
= chain
->last_entry
= NULL
;
3424 return highest_data
;
3427 entry
= bfd_malloc (sizeof * entry
);
3431 chain
->first_entry
= entry
;
3433 for (i
= chain
->num_entries
; i
--;)
3435 bfd_byte
* entry_end
;
3437 entry_end
= rsrc_parse_entry (abfd
, is_name
, entry
, datastart
,
3438 data
, dataend
, rva_bias
, parent
);
3440 highest_data
= max (entry_end
, highest_data
);
3441 if (entry_end
> dataend
)
3446 entry
->next_entry
= bfd_malloc (sizeof * entry
);
3447 entry
= entry
->next_entry
;
3452 entry
->next_entry
= NULL
;
3455 chain
->last_entry
= entry
;
3457 return highest_data
;
3461 rsrc_parse_directory (bfd
* abfd
,
3462 rsrc_directory
* table
,
3463 bfd_byte
* datastart
,
3469 bfd_byte
* highest_data
= data
;
3474 table
->characteristics
= bfd_get_32 (abfd
, data
);
3475 table
->time
= bfd_get_32 (abfd
, data
+ 4);
3476 table
->major
= bfd_get_16 (abfd
, data
+ 8);
3477 table
->minor
= bfd_get_16 (abfd
, data
+ 10);
3478 table
->names
.num_entries
= bfd_get_16 (abfd
, data
+ 12);
3479 table
->ids
.num_entries
= bfd_get_16 (abfd
, data
+ 14);
3480 table
->entry
= entry
;
3484 highest_data
= rsrc_parse_entries (abfd
, & table
->names
, TRUE
, data
,
3485 datastart
, data
, dataend
, rva_bias
, table
);
3486 data
+= table
->names
.num_entries
* 8;
3488 highest_data
= rsrc_parse_entries (abfd
, & table
->ids
, FALSE
, highest_data
,
3489 datastart
, data
, dataend
, rva_bias
, table
);
3490 data
+= table
->ids
.num_entries
* 8;
3492 return max (highest_data
, data
);
3495 typedef struct rsrc_write_data
3498 bfd_byte
* datastart
;
3499 bfd_byte
* next_table
;
3500 bfd_byte
* next_leaf
;
3501 bfd_byte
* next_string
;
3502 bfd_byte
* next_data
;
3507 rsrc_write_string (rsrc_write_data
* data
,
3508 rsrc_string
* string
)
3510 bfd_put_16 (data
->abfd
, string
->len
, data
->next_string
);
3511 memcpy (data
->next_string
+ 2, string
->string
, string
->len
* 2);
3512 data
->next_string
+= (string
->len
+ 1) * 2;
3515 static inline unsigned int
3516 rsrc_compute_rva (rsrc_write_data
* data
,
3519 return (addr
- data
->datastart
) + data
->rva_bias
;
3523 rsrc_write_leaf (rsrc_write_data
* data
,
3526 bfd_put_32 (data
->abfd
, rsrc_compute_rva (data
, data
->next_data
),
3528 bfd_put_32 (data
->abfd
, leaf
->size
, data
->next_leaf
+ 4);
3529 bfd_put_32 (data
->abfd
, leaf
->codepage
, data
->next_leaf
+ 8);
3530 bfd_put_32 (data
->abfd
, 0 /*reserved*/, data
->next_leaf
+ 12);
3531 data
->next_leaf
+= 16;
3533 memcpy (data
->next_data
, leaf
->data
, leaf
->size
);
3534 /* An undocumented feature of Windows resources is that each unit
3535 of raw data is 8-byte aligned... */
3536 data
->next_data
+= ((leaf
->size
+ 7) & ~7);
3539 static void rsrc_write_directory (rsrc_write_data
*, rsrc_directory
*);
3542 rsrc_write_entry (rsrc_write_data
* data
,
3548 bfd_put_32 (data
->abfd
,
3549 SetHighBit (data
->next_string
- data
->datastart
),
3551 rsrc_write_string (data
, & entry
->name_id
.name
);
3554 bfd_put_32 (data
->abfd
, entry
->name_id
.id
, where
);
3558 bfd_put_32 (data
->abfd
,
3559 SetHighBit (data
->next_table
- data
->datastart
),
3561 rsrc_write_directory (data
, entry
->value
.directory
);
3565 bfd_put_32 (data
->abfd
, data
->next_leaf
- data
->datastart
, where
+ 4);
3566 rsrc_write_leaf (data
, entry
->value
.leaf
);
3571 rsrc_compute_region_sizes (rsrc_directory
* dir
)
3573 struct rsrc_entry
* entry
;
3578 sizeof_tables_and_entries
+= 16;
3580 for (entry
= dir
->names
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3582 sizeof_tables_and_entries
+= 8;
3584 sizeof_strings
+= (entry
->name_id
.name
.len
+ 1) * 2;
3587 rsrc_compute_region_sizes (entry
->value
.directory
);
3589 sizeof_leaves
+= 16;
3592 for (entry
= dir
->ids
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3594 sizeof_tables_and_entries
+= 8;
3597 rsrc_compute_region_sizes (entry
->value
.directory
);
3599 sizeof_leaves
+= 16;
3604 rsrc_write_directory (rsrc_write_data
* data
,
3605 rsrc_directory
* dir
)
3609 bfd_byte
* next_entry
;
3612 bfd_put_32 (data
->abfd
, dir
->characteristics
, data
->next_table
);
3613 bfd_put_32 (data
->abfd
, 0 /*dir->time*/, data
->next_table
+ 4);
3614 bfd_put_16 (data
->abfd
, dir
->major
, data
->next_table
+ 8);
3615 bfd_put_16 (data
->abfd
, dir
->minor
, data
->next_table
+ 10);
3616 bfd_put_16 (data
->abfd
, dir
->names
.num_entries
, data
->next_table
+ 12);
3617 bfd_put_16 (data
->abfd
, dir
->ids
.num_entries
, data
->next_table
+ 14);
3619 /* Compute where the entries and the next table will be placed. */
3620 next_entry
= data
->next_table
+ 16;
3621 data
->next_table
= next_entry
+ (dir
->names
.num_entries
* 8)
3622 + (dir
->ids
.num_entries
* 8);
3623 nt
= data
->next_table
;
3625 /* Write the entries. */
3626 for (i
= dir
->names
.num_entries
, entry
= dir
->names
.first_entry
;
3627 i
> 0 && entry
!= NULL
;
3628 i
--, entry
= entry
->next_entry
)
3630 BFD_ASSERT (entry
->is_name
);
3631 rsrc_write_entry (data
, next_entry
, entry
);
3634 BFD_ASSERT (i
== 0);
3635 BFD_ASSERT (entry
== NULL
);
3637 for (i
= dir
->ids
.num_entries
, entry
= dir
->ids
.first_entry
;
3638 i
> 0 && entry
!= NULL
;
3639 i
--, entry
= entry
->next_entry
)
3641 BFD_ASSERT (! entry
->is_name
);
3642 rsrc_write_entry (data
, next_entry
, entry
);
3645 BFD_ASSERT (i
== 0);
3646 BFD_ASSERT (entry
== NULL
);
3647 BFD_ASSERT (nt
== next_entry
);
3650 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3651 /* Return the length (number of units) of the first character in S,
3652 putting its 'ucs4_t' representation in *PUC. */
3655 #if defined HAVE_WCTYPE_H
3656 u16_mbtouc (wint_t * puc
, const unsigned short * s
, unsigned int n
)
3658 u16_mbtouc (wchar_t * puc
, const unsigned short * s
, unsigned int n
)
3661 unsigned short c
= * s
;
3663 if (c
< 0xd800 || c
>= 0xe000)
3673 if (s
[1] >= 0xdc00 && s
[1] < 0xe000)
3675 *puc
= 0x10000 + ((c
- 0xd800) << 10) + (s
[1] - 0xdc00);
3681 /* Incomplete multibyte character. */
3687 /* Invalid multibyte character. */
3691 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3693 /* Perform a comparison of two entries. */
3695 rsrc_cmp (bfd_boolean is_name
, rsrc_entry
* a
, rsrc_entry
* b
)
3704 return a
->name_id
.id
- b
->name_id
.id
;
3706 /* We have to perform a case insenstive, unicode string comparison... */
3707 astring
= a
->name_id
.name
.string
;
3708 alen
= a
->name_id
.name
.len
;
3709 bstring
= b
->name_id
.name
.string
;
3710 blen
= b
->name_id
.name
.len
;
3712 #if defined __CYGWIN__ || defined __MINGW32__
3713 /* Under Windows hosts (both Cygwin and Mingw types),
3714 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3715 function however goes by different names in the two environments... */
3719 #define rscpcmp wcsncasecmp
3722 #define rscpcmp wcsnicmp
3725 res
= rscpcmp ((const wchar_t *) astring
, (const wchar_t *) bstring
,
3728 #elif defined HAVE_WCHAR_H
3733 for (i
= min (alen
, blen
); i
--; astring
+= 2, bstring
+= 2)
3735 #if defined HAVE_WCTYPE_H
3743 /* Convert UTF-16 unicode characters into wchar_t characters
3744 so that we can then perform a case insensitive comparison. */
3745 unsigned int Alen
= u16_mbtouc (& awc
, (const unsigned short *) astring
, 2);
3746 unsigned int Blen
= u16_mbtouc (& bwc
, (const unsigned short *) bstring
, 2);
3751 #ifdef HAVE_WCTYPE_H
3752 awc
= towlower (awc
);
3753 bwc
= towlower (bwc
);
3757 res
= wcsncasecmp (& awc
, & bwc
, 1);
3764 /* Do the best we can - a case sensitive, untranslated comparison. */
3765 res
= memcmp (astring
, bstring
, min (alen
, blen
) * 2);
3775 rsrc_print_name (char * buffer
, rsrc_string string
)
3778 bfd_byte
* name
= string
.string
;
3780 for (i
= string
.len
; i
--; name
+= 2)
3781 sprintf (buffer
+ strlen (buffer
), "%.1s", name
);
3785 rsrc_resource_name (rsrc_entry
* entry
, rsrc_directory
* dir
)
3787 static char buffer
[256];
3788 bfd_boolean is_string
= FALSE
;
3792 if (dir
!= NULL
&& dir
->entry
!= NULL
&& dir
->entry
->parent
!= NULL
3793 && dir
->entry
->parent
->entry
!= NULL
)
3795 strcpy (buffer
, "type: ");
3796 if (dir
->entry
->parent
->entry
->is_name
)
3797 rsrc_print_name (buffer
+ strlen (buffer
),
3798 dir
->entry
->parent
->entry
->name_id
.name
);
3801 unsigned int id
= dir
->entry
->parent
->entry
->name_id
.id
;
3803 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3806 case 1: strcat (buffer
, " (CURSOR)"); break;
3807 case 2: strcat (buffer
, " (BITMAP)"); break;
3808 case 3: strcat (buffer
, " (ICON)"); break;
3809 case 4: strcat (buffer
, " (MENU)"); break;
3810 case 5: strcat (buffer
, " (DIALOG)"); break;
3811 case 6: strcat (buffer
, " (STRING)"); is_string
= TRUE
; break;
3812 case 7: strcat (buffer
, " (FONTDIR)"); break;
3813 case 8: strcat (buffer
, " (FONT)"); break;
3814 case 9: strcat (buffer
, " (ACCELERATOR)"); break;
3815 case 10: strcat (buffer
, " (RCDATA)"); break;
3816 case 11: strcat (buffer
, " (MESSAGETABLE)"); break;
3817 case 12: strcat (buffer
, " (GROUP_CURSOR)"); break;
3818 case 14: strcat (buffer
, " (GROUP_ICON)"); break;
3819 case 16: strcat (buffer
, " (VERSION)"); break;
3820 case 17: strcat (buffer
, " (DLGINCLUDE)"); break;
3821 case 19: strcat (buffer
, " (PLUGPLAY)"); break;
3822 case 20: strcat (buffer
, " (VXD)"); break;
3823 case 21: strcat (buffer
, " (ANICURSOR)"); break;
3824 case 22: strcat (buffer
, " (ANIICON)"); break;
3825 case 23: strcat (buffer
, " (HTML)"); break;
3826 case 24: strcat (buffer
, " (MANIFEST)"); break;
3827 case 240: strcat (buffer
, " (DLGINIT)"); break;
3828 case 241: strcat (buffer
, " (TOOLBAR)"); break;
3833 if (dir
!= NULL
&& dir
->entry
!= NULL
)
3835 strcat (buffer
, " name: ");
3836 if (dir
->entry
->is_name
)
3837 rsrc_print_name (buffer
+ strlen (buffer
), dir
->entry
->name_id
.name
);
3840 unsigned int id
= dir
->entry
->name_id
.id
;
3842 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3845 sprintf (buffer
+ strlen (buffer
), " (resource id range: %d - %d)",
3846 (id
- 1) << 4, (id
<< 4) - 1);
3852 strcat (buffer
, " lang: ");
3855 rsrc_print_name (buffer
+ strlen (buffer
), entry
->name_id
.name
);
3857 sprintf (buffer
+ strlen (buffer
), "%x", entry
->name_id
.id
);
3863 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3864 their ID is stored in the NAME entry. The bottom four bits are used as
3865 an index into unicode string table that makes up the data of the leaf.
3866 So identical type-name-lang string resources may not actually be
3869 This function is called when we have detected two string resources with
3870 match top-28-bit IDs. We have to scan the string tables inside the leaves
3871 and discover if there are any real collisions. If there are then we report
3872 them and return FALSE. Otherwise we copy any strings from B into A and
3873 then return TRUE. */
3876 rsrc_merge_string_entries (rsrc_entry
* a ATTRIBUTE_UNUSED
,
3877 rsrc_entry
* b ATTRIBUTE_UNUSED
)
3879 unsigned int copy_needed
= 0;
3883 bfd_byte
* new_data
;
3886 /* Step one: Find out what we have to do. */
3887 BFD_ASSERT (! a
->is_dir
);
3888 astring
= a
->value
.leaf
->data
;
3890 BFD_ASSERT (! b
->is_dir
);
3891 bstring
= b
->value
.leaf
->data
;
3893 for (i
= 0; i
< 16; i
++)
3895 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3896 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3900 copy_needed
+= blen
* 2;
3904 else if (alen
!= blen
)
3905 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3907 /* alen == blen != 0. We might have two identical strings. If so we
3908 can ignore the second one. There is no need for wchar_t vs UTF-16
3909 theatrics here - we are only interested in (case sensitive) equality. */
3910 else if (memcmp (astring
+ 2, bstring
+ 2, alen
* 2) != 0)
3913 astring
+= (alen
+ 1) * 2;
3914 bstring
+= (blen
+ 1) * 2;
3919 if (a
->parent
!= NULL
3920 && a
->parent
->entry
!= NULL
3921 && !a
->parent
->entry
->is_name
)
3922 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3923 ((a
->parent
->entry
->name_id
.id
- 1) << 4) + i
);
3927 if (copy_needed
== 0)
3930 /* If we reach here then A and B must both have non-colliding strings.
3931 (We never get string resources with fully empty string tables).
3932 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3934 new_data
= bfd_malloc (a
->value
.leaf
->size
+ copy_needed
);
3935 if (new_data
== NULL
)
3939 astring
= a
->value
.leaf
->data
;
3940 bstring
= b
->value
.leaf
->data
;
3942 for (i
= 0; i
< 16; i
++)
3944 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3945 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3949 memcpy (nstring
, astring
, (alen
+ 1) * 2);
3950 nstring
+= (alen
+ 1) * 2;
3954 memcpy (nstring
, bstring
, (blen
+ 1) * 2);
3955 nstring
+= (blen
+ 1) * 2;
3963 astring
+= (alen
+ 1) * 2;
3964 bstring
+= (blen
+ 1) * 2;
3967 BFD_ASSERT (nstring
- new_data
== (signed) (a
->value
.leaf
->size
+ copy_needed
));
3969 free (a
->value
.leaf
->data
);
3970 a
->value
.leaf
->data
= new_data
;
3971 a
->value
.leaf
->size
+= copy_needed
;
3976 static void rsrc_merge (rsrc_entry
*, rsrc_entry
*);
3978 /* Sort the entries in given part of the directory.
3979 We use an old fashioned bubble sort because we are dealing
3980 with lists and we want to handle matches specially. */
3983 rsrc_sort_entries (rsrc_dir_chain
* chain
,
3984 bfd_boolean is_name
,
3985 rsrc_directory
* dir
)
3989 rsrc_entry
** points_to_entry
;
3990 bfd_boolean swapped
;
3992 if (chain
->num_entries
< 2)
3998 points_to_entry
= & chain
->first_entry
;
3999 entry
= * points_to_entry
;
4000 next
= entry
->next_entry
;
4004 signed int cmp
= rsrc_cmp (is_name
, entry
, next
);
4008 entry
->next_entry
= next
->next_entry
;
4009 next
->next_entry
= entry
;
4010 * points_to_entry
= next
;
4011 points_to_entry
= & next
->next_entry
;
4012 next
= entry
->next_entry
;
4017 if (entry
->is_dir
&& next
->is_dir
)
4019 /* When we encounter identical directory entries we have to
4020 merge them together. The exception to this rule is for
4021 resource manifests - there can only be one of these,
4022 even if they differ in language. Zero-language manifests
4023 are assumed to be default manifests (provided by the
4024 Cygwin/MinGW build system) and these can be silently dropped,
4025 unless that would reduce the number of manifests to zero.
4026 There should only ever be one non-zero lang manifest -
4027 if there are more it is an error. A non-zero lang
4028 manifest takes precedence over a default manifest. */
4030 && entry
->name_id
.id
== 1
4032 && dir
->entry
!= NULL
4033 && !dir
->entry
->is_name
4034 && dir
->entry
->name_id
.id
== 0x18)
4036 if (next
->value
.directory
->names
.num_entries
== 0
4037 && next
->value
.directory
->ids
.num_entries
== 1
4038 && !next
->value
.directory
->ids
.first_entry
->is_name
4039 && next
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
4040 /* Fall through so that NEXT is dropped. */
4042 else if (entry
->value
.directory
->names
.num_entries
== 0
4043 && entry
->value
.directory
->ids
.num_entries
== 1
4044 && !entry
->value
.directory
->ids
.first_entry
->is_name
4045 && entry
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
4047 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
4048 entry
->next_entry
= next
->next_entry
;
4049 next
->next_entry
= entry
;
4050 * points_to_entry
= next
;
4051 points_to_entry
= & next
->next_entry
;
4052 next
= entry
->next_entry
;
4057 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
4058 bfd_set_error (bfd_error_file_truncated
);
4062 /* Unhook NEXT from the chain. */
4063 /* FIXME: memory loss here. */
4064 entry
->next_entry
= next
->next_entry
;
4065 chain
->num_entries
--;
4066 if (chain
->num_entries
< 2)
4068 next
= next
->next_entry
;
4071 rsrc_merge (entry
, next
);
4073 else if (entry
->is_dir
!= next
->is_dir
)
4075 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
4076 bfd_set_error (bfd_error_file_truncated
);
4081 /* Otherwise with identical leaves we issue an error
4082 message - because there should never be duplicates.
4083 The exception is Type 18/Name 1/Lang 0 which is the
4084 defaul manifest - this can just be dropped. */
4086 && entry
->name_id
.id
== 0
4088 && dir
->entry
!= NULL
4089 && !dir
->entry
->is_name
4090 && dir
->entry
->name_id
.id
== 1
4091 && dir
->entry
->parent
!= NULL
4092 && dir
->entry
->parent
->entry
!= NULL
4093 && !dir
->entry
->parent
->entry
->is_name
4094 && dir
->entry
->parent
->entry
->name_id
.id
== 0x18 /* RT_MANIFEST */)
4096 else if (dir
!= NULL
4097 && dir
->entry
!= NULL
4098 && dir
->entry
->parent
!= NULL
4099 && dir
->entry
->parent
->entry
!= NULL
4100 && !dir
->entry
->parent
->entry
->is_name
4101 && dir
->entry
->parent
->entry
->name_id
.id
== 0x6 /* RT_STRING */)
4103 /* Strings need special handling. */
4104 if (! rsrc_merge_string_entries (entry
, next
))
4106 /* _bfd_error_handler should have been called inside merge_strings. */
4107 bfd_set_error (bfd_error_file_truncated
);
4114 || dir
->entry
== NULL
4115 || dir
->entry
->parent
== NULL
4116 || dir
->entry
->parent
->entry
== NULL
)
4117 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
4119 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
4120 rsrc_resource_name (entry
, dir
));
4121 bfd_set_error (bfd_error_file_truncated
);
4126 /* Unhook NEXT from the chain. */
4127 entry
->next_entry
= next
->next_entry
;
4128 chain
->num_entries
--;
4129 if (chain
->num_entries
< 2)
4131 next
= next
->next_entry
;
4135 points_to_entry
= & entry
->next_entry
;
4137 next
= next
->next_entry
;
4142 chain
->last_entry
= entry
;
4147 /* Attach B's chain onto A. */
4149 rsrc_attach_chain (rsrc_dir_chain
* achain
, rsrc_dir_chain
* bchain
)
4151 if (bchain
->num_entries
== 0)
4154 achain
->num_entries
+= bchain
->num_entries
;
4156 if (achain
->first_entry
== NULL
)
4158 achain
->first_entry
= bchain
->first_entry
;
4159 achain
->last_entry
= bchain
->last_entry
;
4163 achain
->last_entry
->next_entry
= bchain
->first_entry
;
4164 achain
->last_entry
= bchain
->last_entry
;
4167 bchain
->num_entries
= 0;
4168 bchain
->first_entry
= bchain
->last_entry
= NULL
;
4172 rsrc_merge (struct rsrc_entry
* a
, struct rsrc_entry
* b
)
4174 rsrc_directory
* adir
;
4175 rsrc_directory
* bdir
;
4177 BFD_ASSERT (a
->is_dir
);
4178 BFD_ASSERT (b
->is_dir
);
4180 adir
= a
->value
.directory
;
4181 bdir
= b
->value
.directory
;
4183 if (adir
->characteristics
!= bdir
->characteristics
)
4185 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics"));
4186 bfd_set_error (bfd_error_file_truncated
);
4190 if (adir
->major
!= bdir
->major
|| adir
->minor
!= bdir
->minor
)
4192 _bfd_error_handler (_(".rsrc merge failure: differing directory versions"));
4193 bfd_set_error (bfd_error_file_truncated
);
4197 /* Attach B's name chain to A. */
4198 rsrc_attach_chain (& adir
->names
, & bdir
->names
);
4200 /* Attach B's ID chain to A. */
4201 rsrc_attach_chain (& adir
->ids
, & bdir
->ids
);
4203 /* Now sort A's entries. */
4204 rsrc_sort_entries (& adir
->names
, TRUE
, adir
);
4205 rsrc_sort_entries (& adir
->ids
, FALSE
, adir
);
4208 /* Check the .rsrc section. If it contains multiple concatenated
4209 resources then we must merge them properly. Otherwise Windows
4210 will ignore all but the first set. */
4213 rsrc_process_section (bfd
* abfd
,
4214 struct coff_final_link_info
* pfinfo
)
4216 rsrc_directory new_table
;
4222 bfd_byte
* datastart
;
4224 bfd_byte
* new_data
;
4225 unsigned int num_resource_sets
;
4226 rsrc_directory
* type_tables
;
4227 rsrc_write_data write_data
;
4230 unsigned int num_input_rsrc
= 0;
4231 unsigned int max_num_input_rsrc
= 4;
4232 ptrdiff_t * rsrc_sizes
= NULL
;
4234 new_table
.names
.num_entries
= 0;
4235 new_table
.ids
.num_entries
= 0;
4237 sec
= bfd_get_section_by_name (abfd
, ".rsrc");
4238 if (sec
== NULL
|| (size
= sec
->rawsize
) == 0)
4241 pe
= pe_data (abfd
);
4245 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4247 data
= bfd_malloc (size
);
4253 if (! bfd_get_section_contents (abfd
, sec
, data
, 0, size
))
4256 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4257 their lengths. Note - we rely upon the fact that the linker script
4258 does *not* sort the input .rsrc sections, so that the order in the
4259 linkinfo list matches the order in the output .rsrc section.
4261 We need to know the lengths because each input .rsrc section has padding
4262 at the end of a variable amount. (It does not appear to be based upon
4263 the section alignment or the file alignment). We need to skip any
4264 padding bytes when parsing the input .rsrc sections. */
4265 rsrc_sizes
= bfd_malloc (max_num_input_rsrc
* sizeof * rsrc_sizes
);
4266 if (rsrc_sizes
== NULL
)
4269 for (input
= pfinfo
->info
->input_bfds
;
4271 input
= input
->link
.next
)
4273 asection
* rsrc_sec
= bfd_get_section_by_name (input
, ".rsrc");
4275 /* PR 18372 - skip discarded .rsrc sections. */
4276 if (rsrc_sec
!= NULL
&& !discarded_section (rsrc_sec
))
4278 if (num_input_rsrc
== max_num_input_rsrc
)
4280 max_num_input_rsrc
+= 10;
4281 rsrc_sizes
= bfd_realloc (rsrc_sizes
, max_num_input_rsrc
4282 * sizeof * rsrc_sizes
);
4283 if (rsrc_sizes
== NULL
)
4287 BFD_ASSERT (rsrc_sec
->size
> 0);
4288 rsrc_sizes
[num_input_rsrc
++] = rsrc_sec
->size
;
4292 if (num_input_rsrc
< 2)
4295 /* Step one: Walk the section, computing the size of the tables,
4296 leaves and data and decide if we need to do anything. */
4297 dataend
= data
+ size
;
4298 num_resource_sets
= 0;
4300 while (data
< dataend
)
4302 bfd_byte
* p
= data
;
4304 data
= rsrc_count_directory (abfd
, data
, data
, dataend
, rva_bias
);
4308 /* Corrupted .rsrc section - cannot merge. */
4309 _bfd_error_handler (_("%pB: .rsrc merge failure: corrupt .rsrc section"),
4311 bfd_set_error (bfd_error_file_truncated
);
4315 if ((data
- p
) > rsrc_sizes
[num_resource_sets
])
4317 _bfd_error_handler (_("%pB: .rsrc merge failure: unexpected .rsrc size"),
4319 bfd_set_error (bfd_error_file_truncated
);
4322 /* FIXME: Should we add a check for "data - p" being much smaller
4323 than rsrc_sizes[num_resource_sets] ? */
4325 data
= p
+ rsrc_sizes
[num_resource_sets
];
4326 rva_bias
+= data
- p
;
4327 ++ num_resource_sets
;
4329 BFD_ASSERT (num_resource_sets
== num_input_rsrc
);
4331 /* Step two: Walk the data again, building trees of the resources. */
4333 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4335 type_tables
= bfd_malloc (num_resource_sets
* sizeof * type_tables
);
4336 if (type_tables
== NULL
)
4340 while (data
< dataend
)
4342 bfd_byte
* p
= data
;
4344 (void) rsrc_parse_directory (abfd
, type_tables
+ indx
, data
, data
,
4345 dataend
, rva_bias
, NULL
);
4346 data
= p
+ rsrc_sizes
[indx
];
4347 rva_bias
+= data
- p
;
4350 BFD_ASSERT (indx
== num_resource_sets
);
4352 /* Step three: Merge the top level tables (there can be only one).
4354 We must ensure that the merged entries are in ascending order.
4356 We also thread the top level table entries from the old tree onto
4357 the new table, so that they can be pulled off later. */
4359 /* FIXME: Should we verify that all type tables are the same ? */
4360 new_table
.characteristics
= type_tables
[0].characteristics
;
4361 new_table
.time
= type_tables
[0].time
;
4362 new_table
.major
= type_tables
[0].major
;
4363 new_table
.minor
= type_tables
[0].minor
;
4365 /* Chain the NAME entries onto the table. */
4366 new_table
.names
.first_entry
= NULL
;
4367 new_table
.names
.last_entry
= NULL
;
4369 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4370 rsrc_attach_chain (& new_table
.names
, & type_tables
[indx
].names
);
4372 rsrc_sort_entries (& new_table
.names
, TRUE
, & new_table
);
4374 /* Chain the ID entries onto the table. */
4375 new_table
.ids
.first_entry
= NULL
;
4376 new_table
.ids
.last_entry
= NULL
;
4378 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4379 rsrc_attach_chain (& new_table
.ids
, & type_tables
[indx
].ids
);
4381 rsrc_sort_entries (& new_table
.ids
, FALSE
, & new_table
);
4383 /* Step four: Create new contents for the .rsrc section. */
4384 /* Step four point one: Compute the size of each region of the .rsrc section.
4385 We do this now, rather than earlier, as the merging above may have dropped
4387 sizeof_leaves
= sizeof_strings
= sizeof_tables_and_entries
= 0;
4388 rsrc_compute_region_sizes (& new_table
);
4389 /* We increment sizeof_strings to make sure that resource data
4390 starts on an 8-byte boundary. FIXME: Is this correct ? */
4391 sizeof_strings
= (sizeof_strings
+ 7) & ~ 7;
4393 new_data
= bfd_zalloc (abfd
, size
);
4394 if (new_data
== NULL
)
4397 write_data
.abfd
= abfd
;
4398 write_data
.datastart
= new_data
;
4399 write_data
.next_table
= new_data
;
4400 write_data
.next_leaf
= new_data
+ sizeof_tables_and_entries
;
4401 write_data
.next_string
= write_data
.next_leaf
+ sizeof_leaves
;
4402 write_data
.next_data
= write_data
.next_string
+ sizeof_strings
;
4403 write_data
.rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4405 rsrc_write_directory (& write_data
, & new_table
);
4407 /* Step five: Replace the old contents with the new.
4408 We don't recompute the size as it's too late here to shrink section.
4409 See PR ld/20193 for more details. */
4410 bfd_set_section_contents (pfinfo
->output_bfd
, sec
, new_data
, 0, size
);
4411 sec
->size
= sec
->rawsize
= size
;
4414 /* Step six: Free all the memory that we have used. */
4415 /* FIXME: Free the resource tree, if we have one. */
4420 /* Handle the .idata section and other things that need symbol table
4424 _bfd_XXi_final_link_postscript (bfd
* abfd
, struct coff_final_link_info
*pfinfo
)
4426 struct coff_link_hash_entry
*h1
;
4427 struct bfd_link_info
*info
= pfinfo
->info
;
4428 bfd_boolean result
= TRUE
;
4430 /* There are a few fields that need to be filled in now while we
4431 have symbol table access.
4433 The .idata subsections aren't directly available as sections, but
4434 they are in the symbol table, so get them from there. */
4436 /* The import directory. This is the address of .idata$2, with size
4437 of .idata$2 + .idata$3. */
4438 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4439 ".idata$2", FALSE
, FALSE
, TRUE
);
4442 /* PR ld/2729: We cannot rely upon all the output sections having been
4443 created properly, so check before referencing them. Issue a warning
4444 message for any sections tht could not be found. */
4445 if ((h1
->root
.type
== bfd_link_hash_defined
4446 || h1
->root
.type
== bfd_link_hash_defweak
)
4447 && h1
->root
.u
.def
.section
!= NULL
4448 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4449 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
=
4450 (h1
->root
.u
.def
.value
4451 + h1
->root
.u
.def
.section
->output_section
->vma
4452 + h1
->root
.u
.def
.section
->output_offset
);
4456 (_("%pB: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4461 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4462 ".idata$4", FALSE
, FALSE
, TRUE
);
4464 && (h1
->root
.type
== bfd_link_hash_defined
4465 || h1
->root
.type
== bfd_link_hash_defweak
)
4466 && h1
->root
.u
.def
.section
!= NULL
4467 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4468 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].Size
=
4469 ((h1
->root
.u
.def
.value
4470 + h1
->root
.u
.def
.section
->output_section
->vma
4471 + h1
->root
.u
.def
.section
->output_offset
)
4472 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
);
4476 (_("%pB: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4481 /* The import address table. This is the size/address of
4483 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4484 ".idata$5", FALSE
, FALSE
, TRUE
);
4486 && (h1
->root
.type
== bfd_link_hash_defined
4487 || h1
->root
.type
== bfd_link_hash_defweak
)
4488 && h1
->root
.u
.def
.section
!= NULL
4489 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4490 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4491 (h1
->root
.u
.def
.value
4492 + h1
->root
.u
.def
.section
->output_section
->vma
4493 + h1
->root
.u
.def
.section
->output_offset
);
4497 (_("%pB: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4502 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4503 ".idata$6", FALSE
, FALSE
, TRUE
);
4505 && (h1
->root
.type
== bfd_link_hash_defined
4506 || h1
->root
.type
== bfd_link_hash_defweak
)
4507 && h1
->root
.u
.def
.section
!= NULL
4508 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4509 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4510 ((h1
->root
.u
.def
.value
4511 + h1
->root
.u
.def
.section
->output_section
->vma
4512 + h1
->root
.u
.def
.section
->output_offset
)
4513 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
);
4517 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4524 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4525 "__IAT_start__", FALSE
, FALSE
, TRUE
);
4527 && (h1
->root
.type
== bfd_link_hash_defined
4528 || h1
->root
.type
== bfd_link_hash_defweak
)
4529 && h1
->root
.u
.def
.section
!= NULL
4530 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4535 (h1
->root
.u
.def
.value
4536 + h1
->root
.u
.def
.section
->output_section
->vma
4537 + h1
->root
.u
.def
.section
->output_offset
);
4539 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4540 "__IAT_end__", FALSE
, FALSE
, TRUE
);
4542 && (h1
->root
.type
== bfd_link_hash_defined
4543 || h1
->root
.type
== bfd_link_hash_defweak
)
4544 && h1
->root
.u
.def
.section
!= NULL
4545 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4547 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4548 ((h1
->root
.u
.def
.value
4549 + h1
->root
.u
.def
.section
->output_section
->vma
4550 + h1
->root
.u
.def
.section
->output_offset
)
4552 if (pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
!= 0)
4553 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4554 iat_va
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
4559 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4560 " because .idata$6 is missing"), abfd
);
4566 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4567 (bfd_get_symbol_leading_char (abfd
) != 0
4568 ? "__tls_used" : "_tls_used"),
4569 FALSE
, FALSE
, TRUE
);
4572 if ((h1
->root
.type
== bfd_link_hash_defined
4573 || h1
->root
.type
== bfd_link_hash_defweak
)
4574 && h1
->root
.u
.def
.section
!= NULL
4575 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4576 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].VirtualAddress
=
4577 (h1
->root
.u
.def
.value
4578 + h1
->root
.u
.def
.section
->output_section
->vma
4579 + h1
->root
.u
.def
.section
->output_offset
4580 - pe_data (abfd
)->pe_opthdr
.ImageBase
);
4584 (_("%pB: unable to fill in DataDictionary[9] because __tls_used is missing"),
4588 /* According to PECOFF sepcifications by Microsoft version 8.2
4589 the TLS data directory consists of 4 pointers, followed
4590 by two 4-byte integer. This implies that the total size
4591 is different for 32-bit and 64-bit executables. */
4592 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4593 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x18;
4595 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x28;
4599 /* If there is a .pdata section and we have linked pdata finally, we
4600 need to sort the entries ascending. */
4601 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4603 asection
*sec
= bfd_get_section_by_name (abfd
, ".pdata");
4607 bfd_size_type x
= sec
->rawsize
;
4608 bfd_byte
*tmp_data
= NULL
;
4611 tmp_data
= bfd_malloc (x
);
4613 if (tmp_data
!= NULL
)
4615 if (bfd_get_section_contents (abfd
, sec
, tmp_data
, 0, x
))
4619 12, sort_x64_pdata
);
4620 bfd_set_section_contents (pfinfo
->output_bfd
, sec
,
4631 rsrc_process_section (abfd
, pfinfo
);
4633 /* If we couldn't find idata$2, we either have an excessively
4634 trivial program or are in DEEP trouble; we have to assume trivial