1 /* Support for the generic parts of PE/PEI; the common executable parts.
2 Copyright (C) 1995-2019 Free Software Foundation, Inc.
3 Written by Cygnus Solutions.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
23 /* Most of this hacked by Steve Chamberlain <sac@cygnus.com>.
25 PE/PEI rearrangement (and code added): Donn Terry
26 Softway Systems, Inc. */
28 /* Hey look, some documentation [and in a place you expect to find it]!
30 The main reference for the pei format is "Microsoft Portable Executable
31 and Common Object File Format Specification 4.1". Get it if you need to
32 do some serious hacking on this code.
35 "Peering Inside the PE: A Tour of the Win32 Portable Executable
36 File Format", MSJ 1994, Volume 9.
38 The PE/PEI format is also used by .NET. ECMA-335 describes this:
40 "Standard ECMA-335 Common Language Infrastructure (CLI)", 6th Edition, June 2012.
42 This is also available at
43 https://www.ecma-international.org/publications/files/ECMA-ST/ECMA-335.pdf.
45 The *sole* difference between the pe format and the pei format is that the
46 latter has an MSDOS 2.0 .exe header on the front that prints the message
47 "This app must be run under Windows." (or some such).
48 (FIXME: Whether that statement is *really* true or not is unknown.
49 Are there more subtle differences between pe and pei formats?
50 For now assume there aren't. If you find one, then for God sakes
53 The Microsoft docs use the word "image" instead of "executable" because
54 the former can also refer to a DLL (shared library). Confusion can arise
55 because the `i' in `pei' also refers to "image". The `pe' format can
56 also create images (i.e. executables), it's just that to run on a win32
57 system you need to use the pei format.
59 FIXME: Please add more docs here so the next poor fool that has to hack
60 on this code has a chance of getting something accomplished without
61 wasting too much time. */
63 /* This expands into COFF_WITH_pe, COFF_WITH_pep, or COFF_WITH_pex64
64 depending on whether we're compiling for straight PE or PE+. */
70 #include "coff/internal.h"
72 #include "libiberty.h"
80 /* NOTE: it's strange to be including an architecture specific header
81 in what's supposed to be general (to PE/PEI) code. However, that's
82 where the definitions are, and they don't vary per architecture
83 within PE/PEI, so we get them from there. FIXME: The lack of
84 variance is an assumption which may prove to be incorrect if new
85 PE/PEI targets are created. */
86 #if defined COFF_WITH_pex64
87 # include "coff/x86_64.h"
88 #elif defined COFF_WITH_pep
89 # include "coff/ia64.h"
91 # include "coff/i386.h"
97 #include "safe-ctype.h"
99 #if defined COFF_WITH_pep || defined COFF_WITH_pex64
101 # define AOUTSZ PEPAOUTSZ
102 # define PEAOUTHDR PEPAOUTHDR
105 #define HighBitSet(val) ((val) & 0x80000000)
106 #define SetHighBit(val) ((val) | 0x80000000)
107 #define WithoutHighBit(val) ((val) & 0x7fffffff)
109 /* FIXME: This file has various tests of POWERPC_LE_PE. Those tests
110 worked when the code was in peicode.h, but no longer work now that
111 the code is in peigen.c. PowerPC NT is said to be dead. If
112 anybody wants to revive the code, you will have to figure out how
113 to handle those issues. */
116 _bfd_XXi_swap_sym_in (bfd
* abfd
, void * ext1
, void * in1
)
118 SYMENT
*ext
= (SYMENT
*) ext1
;
119 struct internal_syment
*in
= (struct internal_syment
*) in1
;
121 if (ext
->e
.e_name
[0] == 0)
123 in
->_n
._n_n
._n_zeroes
= 0;
124 in
->_n
._n_n
._n_offset
= H_GET_32 (abfd
, ext
->e
.e
.e_offset
);
127 memcpy (in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
129 in
->n_value
= H_GET_32 (abfd
, ext
->e_value
);
130 in
->n_scnum
= (short) H_GET_16 (abfd
, ext
->e_scnum
);
132 if (sizeof (ext
->e_type
) == 2)
133 in
->n_type
= H_GET_16 (abfd
, ext
->e_type
);
135 in
->n_type
= H_GET_32 (abfd
, ext
->e_type
);
137 in
->n_sclass
= H_GET_8 (abfd
, ext
->e_sclass
);
138 in
->n_numaux
= H_GET_8 (abfd
, ext
->e_numaux
);
140 #ifndef STRICT_PE_FORMAT
141 /* This is for Gnu-created DLLs. */
143 /* The section symbols for the .idata$ sections have class 0x68
144 (C_SECTION), which MS documentation indicates is a section
145 symbol. Unfortunately, the value field in the symbol is simply a
146 copy of the .idata section's flags rather than something useful.
147 When these symbols are encountered, change the value to 0 so that
148 they will be handled somewhat correctly in the bfd code. */
149 if (in
->n_sclass
== C_SECTION
)
151 char namebuf
[SYMNMLEN
+ 1];
152 const char *name
= NULL
;
156 /* Create synthetic empty sections as needed. DJ */
157 if (in
->n_scnum
== 0)
161 name
= _bfd_coff_internal_syment_name (abfd
, in
, namebuf
);
164 _bfd_error_handler (_("%pB: unable to find name for empty section"),
166 bfd_set_error (bfd_error_invalid_target
);
170 sec
= bfd_get_section_by_name (abfd
, name
);
172 in
->n_scnum
= sec
->target_index
;
175 if (in
->n_scnum
== 0)
177 int unused_section_number
= 0;
181 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
182 if (unused_section_number
<= sec
->target_index
)
183 unused_section_number
= sec
->target_index
+ 1;
187 name
= (const char *) bfd_alloc (abfd
, strlen (namebuf
) + 1);
190 _bfd_error_handler (_("%pB: out of memory creating name for empty section"),
194 strcpy ((char *) name
, namebuf
);
197 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_DATA
| SEC_LOAD
;
198 sec
= bfd_make_section_anyway_with_flags (abfd
, name
, flags
);
201 _bfd_error_handler (_("%pB: unable to create fake empty section"),
210 sec
->rel_filepos
= 0;
211 sec
->reloc_count
= 0;
212 sec
->line_filepos
= 0;
213 sec
->lineno_count
= 0;
214 sec
->userdata
= NULL
;
216 sec
->alignment_power
= 2;
218 sec
->target_index
= unused_section_number
;
220 in
->n_scnum
= unused_section_number
;
222 in
->n_sclass
= C_STAT
;
226 #ifdef coff_swap_sym_in_hook
227 /* This won't work in peigen.c, but since it's for PPC PE, it's not
229 coff_swap_sym_in_hook (abfd
, ext1
, in1
);
234 abs_finder (bfd
* abfd ATTRIBUTE_UNUSED
, asection
* sec
, void * data
)
236 bfd_vma abs_val
= * (bfd_vma
*) data
;
238 return (sec
->vma
<= abs_val
) && ((sec
->vma
+ (1ULL << 32)) > abs_val
);
242 _bfd_XXi_swap_sym_out (bfd
* abfd
, void * inp
, void * extp
)
244 struct internal_syment
*in
= (struct internal_syment
*) inp
;
245 SYMENT
*ext
= (SYMENT
*) extp
;
247 if (in
->_n
._n_name
[0] == 0)
249 H_PUT_32 (abfd
, 0, ext
->e
.e
.e_zeroes
);
250 H_PUT_32 (abfd
, in
->_n
._n_n
._n_offset
, ext
->e
.e
.e_offset
);
253 memcpy (ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
255 /* The PE32 and PE32+ formats only use 4 bytes to hold the value of a
256 symbol. This is a problem on 64-bit targets where we can generate
257 absolute symbols with values >= 1^32. We try to work around this
258 problem by finding a section whose base address is sufficient to
259 reduce the absolute value to < 1^32, and then transforming the
260 symbol into a section relative symbol. This of course is a hack. */
261 if (sizeof (in
->n_value
) > 4
262 /* The strange computation of the shift amount is here in order to
263 avoid a compile time warning about the comparison always being
264 false. It does not matter if this test fails to work as expected
265 as the worst that can happen is that some absolute symbols are
266 needlessly converted into section relative symbols. */
267 && in
->n_value
> ((1ULL << (sizeof (in
->n_value
) > 4 ? 32 : 31)) - 1)
268 && in
->n_scnum
== N_ABS
)
272 sec
= bfd_sections_find_if (abfd
, abs_finder
, & in
->n_value
);
275 in
->n_value
-= sec
->vma
;
276 in
->n_scnum
= sec
->target_index
;
278 /* else: FIXME: The value is outside the range of any section. This
279 happens for __image_base__ and __ImageBase and maybe some other
280 symbols as well. We should find a way to handle these values. */
283 H_PUT_32 (abfd
, in
->n_value
, ext
->e_value
);
284 H_PUT_16 (abfd
, in
->n_scnum
, ext
->e_scnum
);
286 if (sizeof (ext
->e_type
) == 2)
287 H_PUT_16 (abfd
, in
->n_type
, ext
->e_type
);
289 H_PUT_32 (abfd
, in
->n_type
, ext
->e_type
);
291 H_PUT_8 (abfd
, in
->n_sclass
, ext
->e_sclass
);
292 H_PUT_8 (abfd
, in
->n_numaux
, ext
->e_numaux
);
298 _bfd_XXi_swap_aux_in (bfd
* abfd
,
302 int indx ATTRIBUTE_UNUSED
,
303 int numaux ATTRIBUTE_UNUSED
,
306 AUXENT
*ext
= (AUXENT
*) ext1
;
307 union internal_auxent
*in
= (union internal_auxent
*) in1
;
309 /* PR 17521: Make sure that all fields in the aux structure
311 memset (in
, 0, sizeof * in
);
315 if (ext
->x_file
.x_fname
[0] == 0)
317 in
->x_file
.x_n
.x_zeroes
= 0;
318 in
->x_file
.x_n
.x_offset
= H_GET_32 (abfd
, ext
->x_file
.x_n
.x_offset
);
321 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
329 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN (abfd
, ext
);
330 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC (abfd
, ext
);
331 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO (abfd
, ext
);
332 in
->x_scn
.x_checksum
= H_GET_32 (abfd
, ext
->x_scn
.x_checksum
);
333 in
->x_scn
.x_associated
= H_GET_16 (abfd
, ext
->x_scn
.x_associated
);
334 in
->x_scn
.x_comdat
= H_GET_8 (abfd
, ext
->x_scn
.x_comdat
);
340 in
->x_sym
.x_tagndx
.l
= H_GET_32 (abfd
, ext
->x_sym
.x_tagndx
);
341 in
->x_sym
.x_tvndx
= H_GET_16 (abfd
, ext
->x_sym
.x_tvndx
);
343 if (in_class
== C_BLOCK
|| in_class
== C_FCN
|| ISFCN (type
)
346 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR (abfd
, ext
);
347 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX (abfd
, ext
);
351 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0] =
352 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
353 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1] =
354 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
355 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2] =
356 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
357 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3] =
358 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
363 in
->x_sym
.x_misc
.x_fsize
= H_GET_32 (abfd
, ext
->x_sym
.x_misc
.x_fsize
);
367 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO (abfd
, ext
);
368 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE (abfd
, ext
);
373 _bfd_XXi_swap_aux_out (bfd
* abfd
,
377 int indx ATTRIBUTE_UNUSED
,
378 int numaux ATTRIBUTE_UNUSED
,
381 union internal_auxent
*in
= (union internal_auxent
*) inp
;
382 AUXENT
*ext
= (AUXENT
*) extp
;
384 memset (ext
, 0, AUXESZ
);
389 if (in
->x_file
.x_fname
[0] == 0)
391 H_PUT_32 (abfd
, 0, ext
->x_file
.x_n
.x_zeroes
);
392 H_PUT_32 (abfd
, in
->x_file
.x_n
.x_offset
, ext
->x_file
.x_n
.x_offset
);
395 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
404 PUT_SCN_SCNLEN (abfd
, in
->x_scn
.x_scnlen
, ext
);
405 PUT_SCN_NRELOC (abfd
, in
->x_scn
.x_nreloc
, ext
);
406 PUT_SCN_NLINNO (abfd
, in
->x_scn
.x_nlinno
, ext
);
407 H_PUT_32 (abfd
, in
->x_scn
.x_checksum
, ext
->x_scn
.x_checksum
);
408 H_PUT_16 (abfd
, in
->x_scn
.x_associated
, ext
->x_scn
.x_associated
);
409 H_PUT_8 (abfd
, in
->x_scn
.x_comdat
, ext
->x_scn
.x_comdat
);
415 H_PUT_32 (abfd
, in
->x_sym
.x_tagndx
.l
, ext
->x_sym
.x_tagndx
);
416 H_PUT_16 (abfd
, in
->x_sym
.x_tvndx
, ext
->x_sym
.x_tvndx
);
418 if (in_class
== C_BLOCK
|| in_class
== C_FCN
|| ISFCN (type
)
421 PUT_FCN_LNNOPTR (abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
422 PUT_FCN_ENDNDX (abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
426 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0],
427 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
428 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1],
429 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
430 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2],
431 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
432 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3],
433 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
437 H_PUT_32 (abfd
, in
->x_sym
.x_misc
.x_fsize
, ext
->x_sym
.x_misc
.x_fsize
);
440 PUT_LNSZ_LNNO (abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
441 PUT_LNSZ_SIZE (abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
448 _bfd_XXi_swap_lineno_in (bfd
* abfd
, void * ext1
, void * in1
)
450 LINENO
*ext
= (LINENO
*) ext1
;
451 struct internal_lineno
*in
= (struct internal_lineno
*) in1
;
453 in
->l_addr
.l_symndx
= H_GET_32 (abfd
, ext
->l_addr
.l_symndx
);
454 in
->l_lnno
= GET_LINENO_LNNO (abfd
, ext
);
458 _bfd_XXi_swap_lineno_out (bfd
* abfd
, void * inp
, void * outp
)
460 struct internal_lineno
*in
= (struct internal_lineno
*) inp
;
461 struct external_lineno
*ext
= (struct external_lineno
*) outp
;
462 H_PUT_32 (abfd
, in
->l_addr
.l_symndx
, ext
->l_addr
.l_symndx
);
464 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
469 _bfd_XXi_swap_aouthdr_in (bfd
* abfd
,
473 PEAOUTHDR
* src
= (PEAOUTHDR
*) aouthdr_ext1
;
474 AOUTHDR
* aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
475 struct internal_aouthdr
*aouthdr_int
476 = (struct internal_aouthdr
*) aouthdr_int1
;
477 struct internal_extra_pe_aouthdr
*a
= &aouthdr_int
->pe
;
479 aouthdr_int
->magic
= H_GET_16 (abfd
, aouthdr_ext
->magic
);
480 aouthdr_int
->vstamp
= H_GET_16 (abfd
, aouthdr_ext
->vstamp
);
481 aouthdr_int
->tsize
= GET_AOUTHDR_TSIZE (abfd
, aouthdr_ext
->tsize
);
482 aouthdr_int
->dsize
= GET_AOUTHDR_DSIZE (abfd
, aouthdr_ext
->dsize
);
483 aouthdr_int
->bsize
= GET_AOUTHDR_BSIZE (abfd
, aouthdr_ext
->bsize
);
484 aouthdr_int
->entry
= GET_AOUTHDR_ENTRY (abfd
, aouthdr_ext
->entry
);
485 aouthdr_int
->text_start
=
486 GET_AOUTHDR_TEXT_START (abfd
, aouthdr_ext
->text_start
);
488 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
489 /* PE32+ does not have data_start member! */
490 aouthdr_int
->data_start
=
491 GET_AOUTHDR_DATA_START (abfd
, aouthdr_ext
->data_start
);
492 a
->BaseOfData
= aouthdr_int
->data_start
;
495 a
->Magic
= aouthdr_int
->magic
;
496 a
->MajorLinkerVersion
= H_GET_8 (abfd
, aouthdr_ext
->vstamp
);
497 a
->MinorLinkerVersion
= H_GET_8 (abfd
, aouthdr_ext
->vstamp
+ 1);
498 a
->SizeOfCode
= aouthdr_int
->tsize
;
499 a
->SizeOfInitializedData
= aouthdr_int
->dsize
;
500 a
->SizeOfUninitializedData
= aouthdr_int
->bsize
;
501 a
->AddressOfEntryPoint
= aouthdr_int
->entry
;
502 a
->BaseOfCode
= aouthdr_int
->text_start
;
503 a
->ImageBase
= GET_OPTHDR_IMAGE_BASE (abfd
, src
->ImageBase
);
504 a
->SectionAlignment
= H_GET_32 (abfd
, src
->SectionAlignment
);
505 a
->FileAlignment
= H_GET_32 (abfd
, src
->FileAlignment
);
506 a
->MajorOperatingSystemVersion
=
507 H_GET_16 (abfd
, src
->MajorOperatingSystemVersion
);
508 a
->MinorOperatingSystemVersion
=
509 H_GET_16 (abfd
, src
->MinorOperatingSystemVersion
);
510 a
->MajorImageVersion
= H_GET_16 (abfd
, src
->MajorImageVersion
);
511 a
->MinorImageVersion
= H_GET_16 (abfd
, src
->MinorImageVersion
);
512 a
->MajorSubsystemVersion
= H_GET_16 (abfd
, src
->MajorSubsystemVersion
);
513 a
->MinorSubsystemVersion
= H_GET_16 (abfd
, src
->MinorSubsystemVersion
);
514 a
->Reserved1
= H_GET_32 (abfd
, src
->Reserved1
);
515 a
->SizeOfImage
= H_GET_32 (abfd
, src
->SizeOfImage
);
516 a
->SizeOfHeaders
= H_GET_32 (abfd
, src
->SizeOfHeaders
);
517 a
->CheckSum
= H_GET_32 (abfd
, src
->CheckSum
);
518 a
->Subsystem
= H_GET_16 (abfd
, src
->Subsystem
);
519 a
->DllCharacteristics
= H_GET_16 (abfd
, src
->DllCharacteristics
);
520 a
->SizeOfStackReserve
=
521 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd
, src
->SizeOfStackReserve
);
522 a
->SizeOfStackCommit
=
523 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd
, src
->SizeOfStackCommit
);
524 a
->SizeOfHeapReserve
=
525 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd
, src
->SizeOfHeapReserve
);
526 a
->SizeOfHeapCommit
=
527 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd
, src
->SizeOfHeapCommit
);
528 a
->LoaderFlags
= H_GET_32 (abfd
, src
->LoaderFlags
);
529 a
->NumberOfRvaAndSizes
= H_GET_32 (abfd
, src
->NumberOfRvaAndSizes
);
534 /* PR 17512: Corrupt PE binaries can cause seg-faults. */
535 if (a
->NumberOfRvaAndSizes
> IMAGE_NUMBEROF_DIRECTORY_ENTRIES
)
537 /* xgettext:c-format */
539 (_("%pB: aout header specifies an invalid number of"
540 " data-directory entries: %u"), abfd
, a
->NumberOfRvaAndSizes
);
541 bfd_set_error (bfd_error_bad_value
);
543 /* Paranoia: If the number is corrupt, then assume that the
544 actual entries themselves might be corrupt as well. */
545 a
->NumberOfRvaAndSizes
= 0;
548 for (idx
= 0; idx
< a
->NumberOfRvaAndSizes
; idx
++)
550 /* If data directory is empty, rva also should be 0. */
552 H_GET_32 (abfd
, src
->DataDirectory
[idx
][1]);
554 a
->DataDirectory
[idx
].Size
= size
;
557 a
->DataDirectory
[idx
].VirtualAddress
=
558 H_GET_32 (abfd
, src
->DataDirectory
[idx
][0]);
560 a
->DataDirectory
[idx
].VirtualAddress
= 0;
563 while (idx
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
)
565 a
->DataDirectory
[idx
].Size
= 0;
566 a
->DataDirectory
[idx
].VirtualAddress
= 0;
571 if (aouthdr_int
->entry
)
573 aouthdr_int
->entry
+= a
->ImageBase
;
574 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
575 aouthdr_int
->entry
&= 0xffffffff;
579 if (aouthdr_int
->tsize
)
581 aouthdr_int
->text_start
+= a
->ImageBase
;
582 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
583 aouthdr_int
->text_start
&= 0xffffffff;
587 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
588 /* PE32+ does not have data_start member! */
589 if (aouthdr_int
->dsize
)
591 aouthdr_int
->data_start
+= a
->ImageBase
;
592 aouthdr_int
->data_start
&= 0xffffffff;
597 /* These three fields are normally set up by ppc_relocate_section.
598 In the case of reading a file in, we can pick them up from the
600 first_thunk_address
= a
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
;
601 thunk_size
= a
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
;
602 import_table_size
= a
->DataDirectory
[PE_IMPORT_TABLE
].Size
;
606 /* A support function for below. */
609 add_data_entry (bfd
* abfd
,
610 struct internal_extra_pe_aouthdr
*aout
,
615 asection
*sec
= bfd_get_section_by_name (abfd
, name
);
617 /* Add import directory information if it exists. */
619 && (coff_section_data (abfd
, sec
) != NULL
)
620 && (pei_section_data (abfd
, sec
) != NULL
))
622 /* If data directory is empty, rva also should be 0. */
623 int size
= pei_section_data (abfd
, sec
)->virt_size
;
624 aout
->DataDirectory
[idx
].Size
= size
;
628 aout
->DataDirectory
[idx
].VirtualAddress
=
629 (sec
->vma
- base
) & 0xffffffff;
630 sec
->flags
|= SEC_DATA
;
636 _bfd_XXi_swap_aouthdr_out (bfd
* abfd
, void * in
, void * out
)
638 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*) in
;
639 pe_data_type
*pe
= pe_data (abfd
);
640 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
641 PEAOUTHDR
*aouthdr_out
= (PEAOUTHDR
*) out
;
643 IMAGE_DATA_DIRECTORY idata2
, idata5
, tls
;
645 sa
= extra
->SectionAlignment
;
646 fa
= extra
->FileAlignment
;
647 ib
= extra
->ImageBase
;
649 idata2
= pe
->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
];
650 idata5
= pe
->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
];
651 tls
= pe
->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
];
653 if (aouthdr_in
->tsize
)
655 aouthdr_in
->text_start
-= ib
;
656 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
657 aouthdr_in
->text_start
&= 0xffffffff;
661 if (aouthdr_in
->dsize
)
663 aouthdr_in
->data_start
-= ib
;
664 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
665 aouthdr_in
->data_start
&= 0xffffffff;
669 if (aouthdr_in
->entry
)
671 aouthdr_in
->entry
-= ib
;
672 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
673 aouthdr_in
->entry
&= 0xffffffff;
677 #define FA(x) (((x) + fa -1 ) & (- fa))
678 #define SA(x) (((x) + sa -1 ) & (- sa))
680 /* We like to have the sizes aligned. */
681 aouthdr_in
->bsize
= FA (aouthdr_in
->bsize
);
683 extra
->NumberOfRvaAndSizes
= IMAGE_NUMBEROF_DIRECTORY_ENTRIES
;
685 add_data_entry (abfd
, extra
, PE_EXPORT_TABLE
, ".edata", ib
);
686 add_data_entry (abfd
, extra
, PE_RESOURCE_TABLE
, ".rsrc", ib
);
687 add_data_entry (abfd
, extra
, PE_EXCEPTION_TABLE
, ".pdata", ib
);
689 /* In theory we do not need to call add_data_entry for .idata$2 or
690 .idata$5. It will be done in bfd_coff_final_link where all the
691 required information is available. If however, we are not going
692 to perform a final link, eg because we have been invoked by objcopy
693 or strip, then we need to make sure that these Data Directory
694 entries are initialised properly.
696 So - we copy the input values into the output values, and then, if
697 a final link is going to be performed, it can overwrite them. */
698 extra
->DataDirectory
[PE_IMPORT_TABLE
] = idata2
;
699 extra
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
] = idata5
;
700 extra
->DataDirectory
[PE_TLS_TABLE
] = tls
;
702 if (extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
== 0)
703 /* Until other .idata fixes are made (pending patch), the entry for
704 .idata is needed for backwards compatibility. FIXME. */
705 add_data_entry (abfd
, extra
, PE_IMPORT_TABLE
, ".idata", ib
);
707 /* For some reason, the virtual size (which is what's set by
708 add_data_entry) for .reloc is not the same as the size recorded
709 in this slot by MSVC; it doesn't seem to cause problems (so far),
710 but since it's the best we've got, use it. It does do the right
712 if (pe
->has_reloc_section
)
713 add_data_entry (abfd
, extra
, PE_BASE_RELOCATION_TABLE
, ".reloc", ib
);
722 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
724 int rounded
= FA (sec
->size
);
726 /* The first non-zero section filepos is the header size.
727 Sections without contents will have a filepos of 0. */
729 hsize
= sec
->filepos
;
730 if (sec
->flags
& SEC_DATA
)
732 if (sec
->flags
& SEC_CODE
)
734 /* The image size is the total VIRTUAL size (which is what is
735 in the virt_size field). Files have been seen (from MSVC
736 5.0 link.exe) where the file size of the .data segment is
737 quite small compared to the virtual size. Without this
738 fix, strip munges the file.
740 FIXME: We need to handle holes between sections, which may
741 happpen when we covert from another format. We just use
742 the virtual address and virtual size of the last section
743 for the image size. */
744 if (coff_section_data (abfd
, sec
) != NULL
745 && pei_section_data (abfd
, sec
) != NULL
)
746 isize
= (sec
->vma
- extra
->ImageBase
747 + SA (FA (pei_section_data (abfd
, sec
)->virt_size
)));
750 aouthdr_in
->dsize
= dsize
;
751 aouthdr_in
->tsize
= tsize
;
752 extra
->SizeOfHeaders
= hsize
;
753 extra
->SizeOfImage
= isize
;
756 H_PUT_16 (abfd
, aouthdr_in
->magic
, aouthdr_out
->standard
.magic
);
758 /* e.g. 219510000 is linker version 2.19 */
759 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
761 /* This piece of magic sets the "linker version" field to
763 H_PUT_16 (abfd
, (LINKER_VERSION
/ 100 + (LINKER_VERSION
% 100) * 256),
764 aouthdr_out
->standard
.vstamp
);
766 PUT_AOUTHDR_TSIZE (abfd
, aouthdr_in
->tsize
, aouthdr_out
->standard
.tsize
);
767 PUT_AOUTHDR_DSIZE (abfd
, aouthdr_in
->dsize
, aouthdr_out
->standard
.dsize
);
768 PUT_AOUTHDR_BSIZE (abfd
, aouthdr_in
->bsize
, aouthdr_out
->standard
.bsize
);
769 PUT_AOUTHDR_ENTRY (abfd
, aouthdr_in
->entry
, aouthdr_out
->standard
.entry
);
770 PUT_AOUTHDR_TEXT_START (abfd
, aouthdr_in
->text_start
,
771 aouthdr_out
->standard
.text_start
);
773 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
774 /* PE32+ does not have data_start member! */
775 PUT_AOUTHDR_DATA_START (abfd
, aouthdr_in
->data_start
,
776 aouthdr_out
->standard
.data_start
);
779 PUT_OPTHDR_IMAGE_BASE (abfd
, extra
->ImageBase
, aouthdr_out
->ImageBase
);
780 H_PUT_32 (abfd
, extra
->SectionAlignment
, aouthdr_out
->SectionAlignment
);
781 H_PUT_32 (abfd
, extra
->FileAlignment
, aouthdr_out
->FileAlignment
);
782 H_PUT_16 (abfd
, extra
->MajorOperatingSystemVersion
,
783 aouthdr_out
->MajorOperatingSystemVersion
);
784 H_PUT_16 (abfd
, extra
->MinorOperatingSystemVersion
,
785 aouthdr_out
->MinorOperatingSystemVersion
);
786 H_PUT_16 (abfd
, extra
->MajorImageVersion
, aouthdr_out
->MajorImageVersion
);
787 H_PUT_16 (abfd
, extra
->MinorImageVersion
, aouthdr_out
->MinorImageVersion
);
788 H_PUT_16 (abfd
, extra
->MajorSubsystemVersion
,
789 aouthdr_out
->MajorSubsystemVersion
);
790 H_PUT_16 (abfd
, extra
->MinorSubsystemVersion
,
791 aouthdr_out
->MinorSubsystemVersion
);
792 H_PUT_32 (abfd
, extra
->Reserved1
, aouthdr_out
->Reserved1
);
793 H_PUT_32 (abfd
, extra
->SizeOfImage
, aouthdr_out
->SizeOfImage
);
794 H_PUT_32 (abfd
, extra
->SizeOfHeaders
, aouthdr_out
->SizeOfHeaders
);
795 H_PUT_32 (abfd
, extra
->CheckSum
, aouthdr_out
->CheckSum
);
796 H_PUT_16 (abfd
, extra
->Subsystem
, aouthdr_out
->Subsystem
);
797 H_PUT_16 (abfd
, extra
->DllCharacteristics
, aouthdr_out
->DllCharacteristics
);
798 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd
, extra
->SizeOfStackReserve
,
799 aouthdr_out
->SizeOfStackReserve
);
800 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd
, extra
->SizeOfStackCommit
,
801 aouthdr_out
->SizeOfStackCommit
);
802 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd
, extra
->SizeOfHeapReserve
,
803 aouthdr_out
->SizeOfHeapReserve
);
804 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd
, extra
->SizeOfHeapCommit
,
805 aouthdr_out
->SizeOfHeapCommit
);
806 H_PUT_32 (abfd
, extra
->LoaderFlags
, aouthdr_out
->LoaderFlags
);
807 H_PUT_32 (abfd
, extra
->NumberOfRvaAndSizes
,
808 aouthdr_out
->NumberOfRvaAndSizes
);
812 for (idx
= 0; idx
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; idx
++)
814 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].VirtualAddress
,
815 aouthdr_out
->DataDirectory
[idx
][0]);
816 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].Size
,
817 aouthdr_out
->DataDirectory
[idx
][1]);
825 _bfd_XXi_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
828 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
829 struct external_PEI_filehdr
*filehdr_out
= (struct external_PEI_filehdr
*) out
;
831 if (pe_data (abfd
)->has_reloc_section
832 || pe_data (abfd
)->dont_strip_reloc
)
833 filehdr_in
->f_flags
&= ~F_RELFLG
;
835 if (pe_data (abfd
)->dll
)
836 filehdr_in
->f_flags
|= F_DLL
;
838 filehdr_in
->pe
.e_magic
= IMAGE_DOS_SIGNATURE
;
839 filehdr_in
->pe
.e_cblp
= 0x90;
840 filehdr_in
->pe
.e_cp
= 0x3;
841 filehdr_in
->pe
.e_crlc
= 0x0;
842 filehdr_in
->pe
.e_cparhdr
= 0x4;
843 filehdr_in
->pe
.e_minalloc
= 0x0;
844 filehdr_in
->pe
.e_maxalloc
= 0xffff;
845 filehdr_in
->pe
.e_ss
= 0x0;
846 filehdr_in
->pe
.e_sp
= 0xb8;
847 filehdr_in
->pe
.e_csum
= 0x0;
848 filehdr_in
->pe
.e_ip
= 0x0;
849 filehdr_in
->pe
.e_cs
= 0x0;
850 filehdr_in
->pe
.e_lfarlc
= 0x40;
851 filehdr_in
->pe
.e_ovno
= 0x0;
853 for (idx
= 0; idx
< 4; idx
++)
854 filehdr_in
->pe
.e_res
[idx
] = 0x0;
856 filehdr_in
->pe
.e_oemid
= 0x0;
857 filehdr_in
->pe
.e_oeminfo
= 0x0;
859 for (idx
= 0; idx
< 10; idx
++)
860 filehdr_in
->pe
.e_res2
[idx
] = 0x0;
862 filehdr_in
->pe
.e_lfanew
= 0x80;
864 /* This next collection of data are mostly just characters. It
865 appears to be constant within the headers put on NT exes. */
866 memcpy (filehdr_in
->pe
.dos_message
, pe_data (abfd
)->dos_message
,
867 sizeof (filehdr_in
->pe
.dos_message
));
869 filehdr_in
->pe
.nt_signature
= IMAGE_NT_SIGNATURE
;
871 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
872 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
874 /* Use a real timestamp by default, unless the no-insert-timestamp
875 option was chosen. */
876 if ((pe_data (abfd
)->insert_timestamp
))
877 H_PUT_32 (abfd
, time (0), filehdr_out
->f_timdat
);
879 H_PUT_32 (abfd
, 0, filehdr_out
->f_timdat
);
881 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
882 filehdr_out
->f_symptr
);
883 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
884 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
885 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
887 /* Put in extra dos header stuff. This data remains essentially
888 constant, it just has to be tacked on to the beginning of all exes
890 H_PUT_16 (abfd
, filehdr_in
->pe
.e_magic
, filehdr_out
->e_magic
);
891 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cblp
, filehdr_out
->e_cblp
);
892 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cp
, filehdr_out
->e_cp
);
893 H_PUT_16 (abfd
, filehdr_in
->pe
.e_crlc
, filehdr_out
->e_crlc
);
894 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cparhdr
, filehdr_out
->e_cparhdr
);
895 H_PUT_16 (abfd
, filehdr_in
->pe
.e_minalloc
, filehdr_out
->e_minalloc
);
896 H_PUT_16 (abfd
, filehdr_in
->pe
.e_maxalloc
, filehdr_out
->e_maxalloc
);
897 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ss
, filehdr_out
->e_ss
);
898 H_PUT_16 (abfd
, filehdr_in
->pe
.e_sp
, filehdr_out
->e_sp
);
899 H_PUT_16 (abfd
, filehdr_in
->pe
.e_csum
, filehdr_out
->e_csum
);
900 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ip
, filehdr_out
->e_ip
);
901 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cs
, filehdr_out
->e_cs
);
902 H_PUT_16 (abfd
, filehdr_in
->pe
.e_lfarlc
, filehdr_out
->e_lfarlc
);
903 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ovno
, filehdr_out
->e_ovno
);
905 for (idx
= 0; idx
< 4; idx
++)
906 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res
[idx
], filehdr_out
->e_res
[idx
]);
908 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oemid
, filehdr_out
->e_oemid
);
909 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oeminfo
, filehdr_out
->e_oeminfo
);
911 for (idx
= 0; idx
< 10; idx
++)
912 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res2
[idx
], filehdr_out
->e_res2
[idx
]);
914 H_PUT_32 (abfd
, filehdr_in
->pe
.e_lfanew
, filehdr_out
->e_lfanew
);
916 for (idx
= 0; idx
< 16; idx
++)
917 H_PUT_32 (abfd
, filehdr_in
->pe
.dos_message
[idx
],
918 filehdr_out
->dos_message
[idx
]);
920 /* Also put in the NT signature. */
921 H_PUT_32 (abfd
, filehdr_in
->pe
.nt_signature
, filehdr_out
->nt_signature
);
927 _bfd_XX_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
929 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
930 FILHDR
*filehdr_out
= (FILHDR
*) out
;
932 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
933 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
934 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->f_timdat
);
935 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
, filehdr_out
->f_symptr
);
936 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
937 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
938 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
944 _bfd_XXi_swap_scnhdr_out (bfd
* abfd
, void * in
, void * out
)
946 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*) in
;
947 SCNHDR
*scnhdr_ext
= (SCNHDR
*) out
;
948 unsigned int ret
= SCNHSZ
;
952 memcpy (scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof (scnhdr_int
->s_name
));
954 PUT_SCNHDR_VADDR (abfd
,
955 ((scnhdr_int
->s_vaddr
956 - pe_data (abfd
)->pe_opthdr
.ImageBase
)
958 scnhdr_ext
->s_vaddr
);
960 /* NT wants the size data to be rounded up to the next
961 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
963 if ((scnhdr_int
->s_flags
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
) != 0)
965 if (bfd_pei_p (abfd
))
967 ps
= scnhdr_int
->s_size
;
973 ss
= scnhdr_int
->s_size
;
978 if (bfd_pei_p (abfd
))
979 ps
= scnhdr_int
->s_paddr
;
983 ss
= scnhdr_int
->s_size
;
986 PUT_SCNHDR_SIZE (abfd
, ss
,
989 /* s_paddr in PE is really the virtual size. */
990 PUT_SCNHDR_PADDR (abfd
, ps
, scnhdr_ext
->s_paddr
);
992 PUT_SCNHDR_SCNPTR (abfd
, scnhdr_int
->s_scnptr
,
993 scnhdr_ext
->s_scnptr
);
994 PUT_SCNHDR_RELPTR (abfd
, scnhdr_int
->s_relptr
,
995 scnhdr_ext
->s_relptr
);
996 PUT_SCNHDR_LNNOPTR (abfd
, scnhdr_int
->s_lnnoptr
,
997 scnhdr_ext
->s_lnnoptr
);
1000 /* Extra flags must be set when dealing with PE. All sections should also
1001 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
1002 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
1003 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
1004 (this is especially important when dealing with the .idata section since
1005 the addresses for routines from .dlls must be overwritten). If .reloc
1006 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
1007 (0x02000000). Also, the resource data should also be read and
1010 /* FIXME: Alignment is also encoded in this field, at least on PPC and
1011 ARM-WINCE. Although - how do we get the original alignment field
1016 char section_name
[SCNNMLEN
];
1017 unsigned long must_have
;
1019 pe_required_section_flags
;
1021 pe_required_section_flags known_sections
[] =
1023 { ".arch", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
| IMAGE_SCN_ALIGN_8BYTES
},
1024 { ".bss", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1025 { ".data", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1026 { ".edata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1027 { ".idata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1028 { ".pdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1029 { ".rdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1030 { ".reloc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
},
1031 { ".rsrc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1032 { ".text" , IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_CODE
| IMAGE_SCN_MEM_EXECUTE
},
1033 { ".tls", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1034 { ".xdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1037 pe_required_section_flags
* p
;
1039 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1040 we know exactly what this specific section wants so we remove it
1041 and then allow the must_have field to add it back in if necessary.
1042 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1043 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
1044 by ld --enable-auto-import (if auto-import is actually needed),
1045 by ld --omagic, or by obcopy --writable-text. */
1047 for (p
= known_sections
;
1048 p
< known_sections
+ ARRAY_SIZE (known_sections
);
1050 if (memcmp (scnhdr_int
->s_name
, p
->section_name
, SCNNMLEN
) == 0)
1052 if (memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text")
1053 || (bfd_get_file_flags (abfd
) & WP_TEXT
))
1054 scnhdr_int
->s_flags
&= ~IMAGE_SCN_MEM_WRITE
;
1055 scnhdr_int
->s_flags
|= p
->must_have
;
1059 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1062 if (coff_data (abfd
)->link_info
1063 && ! bfd_link_relocatable (coff_data (abfd
)->link_info
)
1064 && ! bfd_link_pic (coff_data (abfd
)->link_info
)
1065 && memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text") == 0)
1067 /* By inference from looking at MS output, the 32 bit field
1068 which is the combination of the number_of_relocs and
1069 number_of_linenos is used for the line number count in
1070 executables. A 16-bit field won't do for cc1. The MS
1071 document says that the number of relocs is zero for
1072 executables, but the 17-th bit has been observed to be there.
1073 Overflow is not an issue: a 4G-line program will overflow a
1074 bunch of other fields long before this! */
1075 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
& 0xffff), scnhdr_ext
->s_nlnno
);
1076 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
>> 16), scnhdr_ext
->s_nreloc
);
1080 if (scnhdr_int
->s_nlnno
<= 0xffff)
1081 H_PUT_16 (abfd
, scnhdr_int
->s_nlnno
, scnhdr_ext
->s_nlnno
);
1084 /* xgettext:c-format */
1085 _bfd_error_handler (_("%pB: line number overflow: 0x%lx > 0xffff"),
1086 abfd
, scnhdr_int
->s_nlnno
);
1087 bfd_set_error (bfd_error_file_truncated
);
1088 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nlnno
);
1092 /* Although we could encode 0xffff relocs here, we do not, to be
1093 consistent with other parts of bfd. Also it lets us warn, as
1094 we should never see 0xffff here w/o having the overflow flag
1096 if (scnhdr_int
->s_nreloc
< 0xffff)
1097 H_PUT_16 (abfd
, scnhdr_int
->s_nreloc
, scnhdr_ext
->s_nreloc
);
1100 /* PE can deal with large #s of relocs, but not here. */
1101 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nreloc
);
1102 scnhdr_int
->s_flags
|= IMAGE_SCN_LNK_NRELOC_OVFL
;
1103 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1110 _bfd_XXi_swap_debugdir_in (bfd
* abfd
, void * ext1
, void * in1
)
1112 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) ext1
;
1113 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) in1
;
1115 in
->Characteristics
= H_GET_32(abfd
, ext
->Characteristics
);
1116 in
->TimeDateStamp
= H_GET_32(abfd
, ext
->TimeDateStamp
);
1117 in
->MajorVersion
= H_GET_16(abfd
, ext
->MajorVersion
);
1118 in
->MinorVersion
= H_GET_16(abfd
, ext
->MinorVersion
);
1119 in
->Type
= H_GET_32(abfd
, ext
->Type
);
1120 in
->SizeOfData
= H_GET_32(abfd
, ext
->SizeOfData
);
1121 in
->AddressOfRawData
= H_GET_32(abfd
, ext
->AddressOfRawData
);
1122 in
->PointerToRawData
= H_GET_32(abfd
, ext
->PointerToRawData
);
1126 _bfd_XXi_swap_debugdir_out (bfd
* abfd
, void * inp
, void * extp
)
1128 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) extp
;
1129 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) inp
;
1131 H_PUT_32(abfd
, in
->Characteristics
, ext
->Characteristics
);
1132 H_PUT_32(abfd
, in
->TimeDateStamp
, ext
->TimeDateStamp
);
1133 H_PUT_16(abfd
, in
->MajorVersion
, ext
->MajorVersion
);
1134 H_PUT_16(abfd
, in
->MinorVersion
, ext
->MinorVersion
);
1135 H_PUT_32(abfd
, in
->Type
, ext
->Type
);
1136 H_PUT_32(abfd
, in
->SizeOfData
, ext
->SizeOfData
);
1137 H_PUT_32(abfd
, in
->AddressOfRawData
, ext
->AddressOfRawData
);
1138 H_PUT_32(abfd
, in
->PointerToRawData
, ext
->PointerToRawData
);
1140 return sizeof (struct external_IMAGE_DEBUG_DIRECTORY
);
1144 _bfd_XXi_slurp_codeview_record (bfd
* abfd
, file_ptr where
, unsigned long length
, CODEVIEW_INFO
*cvinfo
)
1148 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1151 if (bfd_bread (buffer
, 256, abfd
) < 4)
1154 /* Ensure null termination of filename. */
1157 cvinfo
->CVSignature
= H_GET_32 (abfd
, buffer
);
1160 if ((cvinfo
->CVSignature
== CVINFO_PDB70_CVSIGNATURE
)
1161 && (length
> sizeof (CV_INFO_PDB70
)))
1163 CV_INFO_PDB70
*cvinfo70
= (CV_INFO_PDB70
*)(buffer
);
1165 cvinfo
->Age
= H_GET_32(abfd
, cvinfo70
->Age
);
1167 /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1168 by 8 single bytes. Byte swap them so we can conveniently treat the GUID
1169 as 16 bytes in big-endian order. */
1170 bfd_putb32 (bfd_getl32 (cvinfo70
->Signature
), cvinfo
->Signature
);
1171 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[4])), &(cvinfo
->Signature
[4]));
1172 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[6])), &(cvinfo
->Signature
[6]));
1173 memcpy (&(cvinfo
->Signature
[8]), &(cvinfo70
->Signature
[8]), 8);
1175 cvinfo
->SignatureLength
= CV_INFO_SIGNATURE_LENGTH
;
1176 // cvinfo->PdbFileName = cvinfo70->PdbFileName;
1180 else if ((cvinfo
->CVSignature
== CVINFO_PDB20_CVSIGNATURE
)
1181 && (length
> sizeof (CV_INFO_PDB20
)))
1183 CV_INFO_PDB20
*cvinfo20
= (CV_INFO_PDB20
*)(buffer
);
1184 cvinfo
->Age
= H_GET_32(abfd
, cvinfo20
->Age
);
1185 memcpy (cvinfo
->Signature
, cvinfo20
->Signature
, 4);
1186 cvinfo
->SignatureLength
= 4;
1187 // cvinfo->PdbFileName = cvinfo20->PdbFileName;
1196 _bfd_XXi_write_codeview_record (bfd
* abfd
, file_ptr where
, CODEVIEW_INFO
*cvinfo
)
1198 const bfd_size_type size
= sizeof (CV_INFO_PDB70
) + 1;
1199 bfd_size_type written
;
1200 CV_INFO_PDB70
*cvinfo70
;
1203 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1206 buffer
= bfd_malloc (size
);
1210 cvinfo70
= (CV_INFO_PDB70
*) buffer
;
1211 H_PUT_32 (abfd
, CVINFO_PDB70_CVSIGNATURE
, cvinfo70
->CvSignature
);
1213 /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1214 in little-endian order, followed by 8 single bytes. */
1215 bfd_putl32 (bfd_getb32 (cvinfo
->Signature
), cvinfo70
->Signature
);
1216 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[4])), &(cvinfo70
->Signature
[4]));
1217 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[6])), &(cvinfo70
->Signature
[6]));
1218 memcpy (&(cvinfo70
->Signature
[8]), &(cvinfo
->Signature
[8]), 8);
1220 H_PUT_32 (abfd
, cvinfo
->Age
, cvinfo70
->Age
);
1221 cvinfo70
->PdbFileName
[0] = '\0';
1223 written
= bfd_bwrite (buffer
, size
, abfd
);
1227 return written
== size
? size
: 0;
1230 static char * dir_names
[IMAGE_NUMBEROF_DIRECTORY_ENTRIES
] =
1232 N_("Export Directory [.edata (or where ever we found it)]"),
1233 N_("Import Directory [parts of .idata]"),
1234 N_("Resource Directory [.rsrc]"),
1235 N_("Exception Directory [.pdata]"),
1236 N_("Security Directory"),
1237 N_("Base Relocation Directory [.reloc]"),
1238 N_("Debug Directory"),
1239 N_("Description Directory"),
1240 N_("Special Directory"),
1241 N_("Thread Storage Directory [.tls]"),
1242 N_("Load Configuration Directory"),
1243 N_("Bound Import Directory"),
1244 N_("Import Address Table Directory"),
1245 N_("Delay Import Directory"),
1246 N_("CLR Runtime Header"),
1250 #ifdef POWERPC_LE_PE
1251 /* The code for the PPC really falls in the "architecture dependent"
1252 category. However, it's not clear that anyone will ever care, so
1253 we're ignoring the issue for now; if/when PPC matters, some of this
1254 may need to go into peicode.h, or arguments passed to enable the
1255 PPC- specific code. */
1259 pe_print_idata (bfd
* abfd
, void * vfile
)
1261 FILE *file
= (FILE *) vfile
;
1266 #ifdef POWERPC_LE_PE
1267 asection
*rel_section
= bfd_get_section_by_name (abfd
, ".reldata");
1270 bfd_size_type datasize
= 0;
1271 bfd_size_type dataoff
;
1275 pe_data_type
*pe
= pe_data (abfd
);
1276 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1280 addr
= extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
;
1282 if (addr
== 0 && extra
->DataDirectory
[PE_IMPORT_TABLE
].Size
== 0)
1284 /* Maybe the extra header isn't there. Look for the section. */
1285 section
= bfd_get_section_by_name (abfd
, ".idata");
1286 if (section
== NULL
)
1289 addr
= section
->vma
;
1290 datasize
= section
->size
;
1296 addr
+= extra
->ImageBase
;
1297 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1299 datasize
= section
->size
;
1300 if (addr
>= section
->vma
&& addr
< section
->vma
+ datasize
)
1304 if (section
== NULL
)
1307 _("\nThere is an import table, but the section containing it could not be found\n"));
1310 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1313 _("\nThere is an import table in %s, but that section has no contents\n"),
1319 /* xgettext:c-format */
1320 fprintf (file
, _("\nThere is an import table in %s at 0x%lx\n"),
1321 section
->name
, (unsigned long) addr
);
1323 dataoff
= addr
- section
->vma
;
1325 #ifdef POWERPC_LE_PE
1326 if (rel_section
!= 0 && rel_section
->size
!= 0)
1328 /* The toc address can be found by taking the starting address,
1329 which on the PPC locates a function descriptor. The
1330 descriptor consists of the function code starting address
1331 followed by the address of the toc. The starting address we
1332 get from the bfd, and the descriptor is supposed to be in the
1333 .reldata section. */
1335 bfd_vma loadable_toc_address
;
1336 bfd_vma toc_address
;
1337 bfd_vma start_address
;
1341 if (!bfd_malloc_and_get_section (abfd
, rel_section
, &data
))
1348 offset
= abfd
->start_address
- rel_section
->vma
;
1350 if (offset
>= rel_section
->size
|| offset
+ 8 > rel_section
->size
)
1357 start_address
= bfd_get_32 (abfd
, data
+ offset
);
1358 loadable_toc_address
= bfd_get_32 (abfd
, data
+ offset
+ 4);
1359 toc_address
= loadable_toc_address
- 32768;
1362 _("\nFunction descriptor located at the start address: %04lx\n"),
1363 (unsigned long int) (abfd
->start_address
));
1365 /* xgettext:c-format */
1366 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1367 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
))
1394 adj
= section
->vma
- extra
->ImageBase
;
1396 /* Print all image import descriptors. */
1397 for (i
= dataoff
; i
+ onaline
<= datasize
; i
+= onaline
)
1401 bfd_vma forward_chain
;
1403 bfd_vma first_thunk
;
1408 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1409 fprintf (file
, " %08lx\t", (unsigned long) (i
+ adj
));
1410 hint_addr
= bfd_get_32 (abfd
, data
+ i
);
1411 time_stamp
= bfd_get_32 (abfd
, data
+ i
+ 4);
1412 forward_chain
= bfd_get_32 (abfd
, data
+ i
+ 8);
1413 dll_name
= bfd_get_32 (abfd
, data
+ i
+ 12);
1414 first_thunk
= bfd_get_32 (abfd
, data
+ i
+ 16);
1416 fprintf (file
, "%08lx %08lx %08lx %08lx %08lx\n",
1417 (unsigned long) hint_addr
,
1418 (unsigned long) time_stamp
,
1419 (unsigned long) forward_chain
,
1420 (unsigned long) dll_name
,
1421 (unsigned long) first_thunk
);
1423 if (hint_addr
== 0 && first_thunk
== 0)
1426 if (dll_name
- adj
>= section
->size
)
1429 dll
= (char *) data
+ dll_name
- adj
;
1430 /* PR 17512 file: 078-12277-0.004. */
1431 bfd_size_type maxlen
= (char *)(data
+ datasize
) - dll
- 1;
1432 fprintf (file
, _("\n\tDLL Name: %.*s\n"), (int) maxlen
, dll
);
1434 /* PR 21546: When the Hint Address is zero,
1435 we try the First Thunk instead. */
1437 hint_addr
= first_thunk
;
1439 if (hint_addr
!= 0 && hint_addr
- adj
< datasize
)
1442 asection
*ft_section
;
1444 bfd_size_type ft_datasize
;
1448 fprintf (file
, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1450 idx
= hint_addr
- adj
;
1452 ft_addr
= first_thunk
+ extra
->ImageBase
;
1453 ft_idx
= first_thunk
- adj
;
1454 ft_data
= data
+ ft_idx
;
1455 ft_datasize
= datasize
- ft_idx
;
1458 if (first_thunk
!= hint_addr
)
1460 /* Find the section which contains the first thunk. */
1461 for (ft_section
= abfd
->sections
;
1463 ft_section
= ft_section
->next
)
1465 if (ft_addr
>= ft_section
->vma
1466 && ft_addr
< ft_section
->vma
+ ft_section
->size
)
1470 if (ft_section
== NULL
)
1473 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1477 /* Now check to see if this section is the same as our current
1478 section. If it is not then we will have to load its data in. */
1479 if (ft_section
!= section
)
1481 ft_idx
= first_thunk
- (ft_section
->vma
- extra
->ImageBase
);
1482 ft_datasize
= ft_section
->size
- ft_idx
;
1483 ft_data
= (bfd_byte
*) bfd_malloc (ft_datasize
);
1484 if (ft_data
== NULL
)
1487 /* Read ft_datasize bytes starting at offset ft_idx. */
1488 if (!bfd_get_section_contents (abfd
, ft_section
, ft_data
,
1489 (bfd_vma
) ft_idx
, ft_datasize
))
1498 /* Print HintName vector entries. */
1499 #ifdef COFF_WITH_pex64
1500 for (j
= 0; idx
+ j
+ 8 <= datasize
; j
+= 8)
1503 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1504 unsigned long member_high
= bfd_get_32 (abfd
, data
+ idx
+ j
+ 4);
1506 if (!member
&& !member_high
)
1511 if (HighBitSet (member_high
))
1512 fprintf (file
, "\t%lx%08lx\t %4lx%08lx <none>",
1513 member_high
, member
,
1514 WithoutHighBit (member_high
), member
);
1515 /* PR binutils/17512: Handle corrupt PE data. */
1516 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1517 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1523 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1524 member_name
= (char *) data
+ amt
+ 2;
1525 fprintf (file
, "\t%04lx\t %4d %.*s",member
, ordinal
,
1526 (int) (datasize
- (amt
+ 2)), member_name
);
1529 /* If the time stamp is not zero, the import address
1530 table holds actual addresses. */
1533 && first_thunk
!= hint_addr
1534 && j
+ 4 <= ft_datasize
)
1535 fprintf (file
, "\t%04lx",
1536 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1537 fprintf (file
, "\n");
1540 for (j
= 0; idx
+ j
+ 4 <= datasize
; j
+= 4)
1543 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1545 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1551 if (HighBitSet (member
))
1552 fprintf (file
, "\t%04lx\t %4lu <none>",
1553 member
, WithoutHighBit (member
));
1554 /* PR binutils/17512: Handle corrupt PE data. */
1555 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1556 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1562 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1563 member_name
= (char *) data
+ amt
+ 2;
1564 fprintf (file
, "\t%04lx\t %4d %.*s",
1566 (int) (datasize
- (amt
+ 2)), member_name
);
1569 /* If the time stamp is not zero, the import address
1570 table holds actual addresses. */
1573 && first_thunk
!= hint_addr
1574 && j
+ 4 <= ft_datasize
)
1575 fprintf (file
, "\t%04lx",
1576 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1578 fprintf (file
, "\n");
1585 fprintf (file
, "\n");
1594 pe_print_edata (bfd
* abfd
, void * vfile
)
1596 FILE *file
= (FILE *) vfile
;
1599 bfd_size_type datasize
= 0;
1600 bfd_size_type dataoff
;
1605 long export_flags
; /* Reserved - should be zero. */
1609 bfd_vma name
; /* RVA - relative to image base. */
1610 long base
; /* Ordinal base. */
1611 unsigned long num_functions
;/* Number in the export address table. */
1612 unsigned long num_names
; /* Number in the name pointer table. */
1613 bfd_vma eat_addr
; /* RVA to the export address table. */
1614 bfd_vma npt_addr
; /* RVA to the Export Name Pointer Table. */
1615 bfd_vma ot_addr
; /* RVA to the Ordinal Table. */
1618 pe_data_type
*pe
= pe_data (abfd
);
1619 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1623 addr
= extra
->DataDirectory
[PE_EXPORT_TABLE
].VirtualAddress
;
1625 if (addr
== 0 && extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
== 0)
1627 /* Maybe the extra header isn't there. Look for the section. */
1628 section
= bfd_get_section_by_name (abfd
, ".edata");
1629 if (section
== NULL
)
1632 addr
= section
->vma
;
1634 datasize
= section
->size
;
1640 addr
+= extra
->ImageBase
;
1642 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1643 if (addr
>= section
->vma
&& addr
< section
->vma
+ section
->size
)
1646 if (section
== NULL
)
1649 _("\nThere is an export table, but the section containing it could not be found\n"));
1652 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1655 _("\nThere is an export table in %s, but that section has no contents\n"),
1660 dataoff
= addr
- section
->vma
;
1661 datasize
= extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
;
1662 if (dataoff
> section
->size
1663 || datasize
> section
->size
- dataoff
)
1666 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1672 /* PR 17512: Handle corrupt PE binaries. */
1676 /* xgettext:c-format */
1677 _("\nThere is an export table in %s, but it is too small (%d)\n"),
1678 section
->name
, (int) datasize
);
1682 /* xgettext:c-format */
1683 fprintf (file
, _("\nThere is an export table in %s at 0x%lx\n"),
1684 section
->name
, (unsigned long) addr
);
1686 data
= (bfd_byte
*) bfd_malloc (datasize
);
1690 if (! bfd_get_section_contents (abfd
, section
, data
,
1691 (file_ptr
) dataoff
, datasize
))
1694 /* Go get Export Directory Table. */
1695 edt
.export_flags
= bfd_get_32 (abfd
, data
+ 0);
1696 edt
.time_stamp
= bfd_get_32 (abfd
, data
+ 4);
1697 edt
.major_ver
= bfd_get_16 (abfd
, data
+ 8);
1698 edt
.minor_ver
= bfd_get_16 (abfd
, data
+ 10);
1699 edt
.name
= bfd_get_32 (abfd
, data
+ 12);
1700 edt
.base
= bfd_get_32 (abfd
, data
+ 16);
1701 edt
.num_functions
= bfd_get_32 (abfd
, data
+ 20);
1702 edt
.num_names
= bfd_get_32 (abfd
, data
+ 24);
1703 edt
.eat_addr
= bfd_get_32 (abfd
, data
+ 28);
1704 edt
.npt_addr
= bfd_get_32 (abfd
, data
+ 32);
1705 edt
.ot_addr
= bfd_get_32 (abfd
, data
+ 36);
1707 adj
= section
->vma
- extra
->ImageBase
+ dataoff
;
1709 /* Dump the EDT first. */
1711 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1715 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt
.export_flags
);
1718 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt
.time_stamp
);
1721 /* xgettext:c-format */
1722 _("Major/Minor \t\t\t%d/%d\n"), edt
.major_ver
, edt
.minor_ver
);
1725 _("Name \t\t\t\t"));
1726 bfd_fprintf_vma (abfd
, file
, edt
.name
);
1728 if ((edt
.name
>= adj
) && (edt
.name
< adj
+ datasize
))
1729 fprintf (file
, " %.*s\n",
1730 (int) (datasize
- (edt
.name
- adj
)),
1731 data
+ edt
.name
- adj
);
1733 fprintf (file
, "(outside .edata section)\n");
1736 _("Ordinal Base \t\t\t%ld\n"), edt
.base
);
1742 _("\tExport Address Table \t\t%08lx\n"),
1746 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt
.num_names
);
1749 _("Table Addresses\n"));
1752 _("\tExport Address Table \t\t"));
1753 bfd_fprintf_vma (abfd
, file
, edt
.eat_addr
);
1754 fprintf (file
, "\n");
1757 _("\tName Pointer Table \t\t"));
1758 bfd_fprintf_vma (abfd
, file
, edt
.npt_addr
);
1759 fprintf (file
, "\n");
1762 _("\tOrdinal Table \t\t\t"));
1763 bfd_fprintf_vma (abfd
, file
, edt
.ot_addr
);
1764 fprintf (file
, "\n");
1766 /* The next table to find is the Export Address Table. It's basically
1767 a list of pointers that either locate a function in this dll, or
1768 forward the call to another dll. Something like:
1773 } export_address_table_entry; */
1776 _("\nExport Address Table -- Ordinal Base %ld\n"),
1779 /* PR 17512: Handle corrupt PE binaries. */
1780 /* PR 17512 file: 140-165018-0.004. */
1781 if (edt
.eat_addr
- adj
>= datasize
1782 /* PR 17512: file: 092b1829 */
1783 || (edt
.num_functions
+ 1) * 4 < edt
.num_functions
1784 || edt
.eat_addr
- adj
+ (edt
.num_functions
+ 1) * 4 > datasize
)
1785 fprintf (file
, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1786 (long) edt
.eat_addr
,
1787 (long) edt
.num_functions
);
1788 else for (i
= 0; i
< edt
.num_functions
; ++i
)
1790 bfd_vma eat_member
= bfd_get_32 (abfd
,
1791 data
+ edt
.eat_addr
+ (i
* 4) - adj
);
1792 if (eat_member
== 0)
1795 if (eat_member
- adj
<= datasize
)
1797 /* This rva is to a name (forwarding function) in our section. */
1798 /* Should locate a function descriptor. */
1800 "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1802 (long) (i
+ edt
.base
),
1803 (unsigned long) eat_member
,
1805 (int)(datasize
- (eat_member
- adj
)),
1806 data
+ eat_member
- adj
);
1810 /* Should locate a function descriptor in the reldata section. */
1812 "\t[%4ld] +base[%4ld] %04lx %s\n",
1814 (long) (i
+ edt
.base
),
1815 (unsigned long) eat_member
,
1820 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1821 /* Dump them in parallel for clarity. */
1823 _("\n[Ordinal/Name Pointer] Table\n"));
1825 /* PR 17512: Handle corrupt PE binaries. */
1826 if (edt
.npt_addr
+ (edt
.num_names
* 4) - adj
>= datasize
1827 /* PR 17512: file: bb68816e. */
1828 || edt
.num_names
* 4 < edt
.num_names
1829 || (data
+ edt
.npt_addr
- adj
) < data
)
1830 /* xgettext:c-format */
1831 fprintf (file
, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1832 (long) edt
.npt_addr
,
1833 (long) edt
.num_names
);
1834 /* PR 17512: file: 140-147171-0.004. */
1835 else if (edt
.ot_addr
+ (edt
.num_names
* 2) - adj
>= datasize
1836 || data
+ edt
.ot_addr
- adj
< data
)
1837 /* xgettext:c-format */
1838 fprintf (file
, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1840 (long) edt
.num_names
);
1841 else for (i
= 0; i
< edt
.num_names
; ++i
)
1846 ord
= bfd_get_16 (abfd
, data
+ edt
.ot_addr
+ (i
* 2) - adj
);
1847 name_ptr
= bfd_get_32 (abfd
, data
+ edt
.npt_addr
+ (i
* 4) - adj
);
1849 if ((name_ptr
- adj
) >= datasize
)
1851 /* xgettext:c-format */
1852 fprintf (file
, _("\t[%4ld] <corrupt offset: %lx>\n"),
1853 (long) ord
, (long) name_ptr
);
1857 char * name
= (char *) data
+ name_ptr
- adj
;
1859 fprintf (file
, "\t[%4ld] %.*s\n", (long) ord
,
1860 (int)((char *)(data
+ datasize
) - name
), name
);
1869 /* This really is architecture dependent. On IA-64, a .pdata entry
1870 consists of three dwords containing relative virtual addresses that
1871 specify the start and end address of the code range the entry
1872 covers and the address of the corresponding unwind info data.
1874 On ARM and SH-4, a compressed PDATA structure is used :
1875 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1876 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1877 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1879 This is the version for uncompressed data. */
1882 pe_print_pdata (bfd
* abfd
, void * vfile
)
1884 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1885 # define PDATA_ROW_SIZE (3 * 8)
1887 # define PDATA_ROW_SIZE (5 * 4)
1889 FILE *file
= (FILE *) vfile
;
1891 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1892 bfd_size_type datasize
= 0;
1894 bfd_size_type start
, stop
;
1895 int onaline
= PDATA_ROW_SIZE
;
1898 || coff_section_data (abfd
, section
) == NULL
1899 || pei_section_data (abfd
, section
) == NULL
)
1902 stop
= pei_section_data (abfd
, section
)->virt_size
;
1903 if ((stop
% onaline
) != 0)
1905 /* xgettext:c-format */
1906 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
1907 (long) stop
, onaline
);
1910 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1911 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1913 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1916 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1917 \t\tAddress Address Handler Data Address Mask\n"));
1920 datasize
= section
->size
;
1924 /* PR 17512: file: 002-193900-0.004. */
1925 if (datasize
< stop
)
1927 /* xgettext:c-format */
1928 fprintf (file
, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"),
1929 (long) stop
, (long) datasize
);
1933 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
1942 for (i
= start
; i
< stop
; i
+= onaline
)
1948 bfd_vma prolog_end_addr
;
1949 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1953 if (i
+ PDATA_ROW_SIZE
> stop
)
1956 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
1957 end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
1958 eh_handler
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 8);
1959 eh_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 12);
1960 prolog_end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 16);
1962 if (begin_addr
== 0 && end_addr
== 0 && eh_handler
== 0
1963 && eh_data
== 0 && prolog_end_addr
== 0)
1964 /* We are probably into the padding of the section now. */
1967 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1968 em_data
= ((eh_handler
& 0x1) << 2) | (prolog_end_addr
& 0x3);
1970 eh_handler
&= ~(bfd_vma
) 0x3;
1971 prolog_end_addr
&= ~(bfd_vma
) 0x3;
1974 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
1975 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
1976 bfd_fprintf_vma (abfd
, file
, end_addr
); fputc (' ', file
);
1977 bfd_fprintf_vma (abfd
, file
, eh_handler
);
1978 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1980 bfd_fprintf_vma (abfd
, file
, eh_data
); fputc (' ', file
);
1981 bfd_fprintf_vma (abfd
, file
, prolog_end_addr
);
1982 fprintf (file
, " %x", em_data
);
1985 #ifdef POWERPC_LE_PE
1986 if (eh_handler
== 0 && eh_data
!= 0)
1988 /* Special bits here, although the meaning may be a little
1989 mysterious. The only one I know for sure is 0x03
1992 0x01 Register Save Millicode
1993 0x02 Register Restore Millicode
1994 0x03 Glue Code Sequence. */
1998 fprintf (file
, _(" Register save millicode"));
2001 fprintf (file
, _(" Register restore millicode"));
2004 fprintf (file
, _(" Glue code sequence"));
2011 fprintf (file
, "\n");
2017 #undef PDATA_ROW_SIZE
2020 typedef struct sym_cache
2027 slurp_symtab (bfd
*abfd
, sym_cache
*psc
)
2029 asymbol
** sy
= NULL
;
2032 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
2038 storage
= bfd_get_symtab_upper_bound (abfd
);
2043 sy
= (asymbol
**) bfd_malloc (storage
);
2048 psc
->symcount
= bfd_canonicalize_symtab (abfd
, sy
);
2049 if (psc
->symcount
< 0)
2055 my_symbol_for_address (bfd
*abfd
, bfd_vma func
, sym_cache
*psc
)
2060 psc
->syms
= slurp_symtab (abfd
, psc
);
2062 for (i
= 0; i
< psc
->symcount
; i
++)
2064 if (psc
->syms
[i
]->section
->vma
+ psc
->syms
[i
]->value
== func
)
2065 return psc
->syms
[i
]->name
;
2072 cleanup_syms (sym_cache
*psc
)
2079 /* This is the version for "compressed" pdata. */
2082 _bfd_XX_print_ce_compressed_pdata (bfd
* abfd
, void * vfile
)
2084 # define PDATA_ROW_SIZE (2 * 4)
2085 FILE *file
= (FILE *) vfile
;
2086 bfd_byte
*data
= NULL
;
2087 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
2088 bfd_size_type datasize
= 0;
2090 bfd_size_type start
, stop
;
2091 int onaline
= PDATA_ROW_SIZE
;
2092 struct sym_cache cache
= {0, 0} ;
2095 || coff_section_data (abfd
, section
) == NULL
2096 || pei_section_data (abfd
, section
) == NULL
)
2099 stop
= pei_section_data (abfd
, section
)->virt_size
;
2100 if ((stop
% onaline
) != 0)
2102 /* xgettext:c-format */
2103 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
2104 (long) stop
, onaline
);
2107 _("\nThe Function Table (interpreted .pdata section contents)\n"));
2110 vma:\t\tBegin Prolog Function Flags Exception EH\n\
2111 \t\tAddress Length Length 32b exc Handler Data\n"));
2113 datasize
= section
->size
;
2117 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2126 for (i
= start
; i
< stop
; i
+= onaline
)
2130 bfd_vma prolog_length
, function_length
;
2131 int flag32bit
, exception_flag
;
2134 if (i
+ PDATA_ROW_SIZE
> stop
)
2137 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
2138 other_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
2140 if (begin_addr
== 0 && other_data
== 0)
2141 /* We are probably into the padding of the section now. */
2144 prolog_length
= (other_data
& 0x000000FF);
2145 function_length
= (other_data
& 0x3FFFFF00) >> 8;
2146 flag32bit
= (int)((other_data
& 0x40000000) >> 30);
2147 exception_flag
= (int)((other_data
& 0x80000000) >> 31);
2150 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
2151 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
2152 bfd_fprintf_vma (abfd
, file
, prolog_length
); fputc (' ', file
);
2153 bfd_fprintf_vma (abfd
, file
, function_length
); fputc (' ', file
);
2154 fprintf (file
, "%2d %2d ", flag32bit
, exception_flag
);
2156 /* Get the exception handler's address and the data passed from the
2157 .text section. This is really the data that belongs with the .pdata
2158 but got "compressed" out for the ARM and SH4 architectures. */
2159 tsection
= bfd_get_section_by_name (abfd
, ".text");
2160 if (tsection
&& coff_section_data (abfd
, tsection
)
2161 && pei_section_data (abfd
, tsection
))
2163 bfd_vma eh_off
= (begin_addr
- 8) - tsection
->vma
;
2166 tdata
= (bfd_byte
*) bfd_malloc (8);
2169 if (bfd_get_section_contents (abfd
, tsection
, tdata
, eh_off
, 8))
2171 bfd_vma eh
, eh_data
;
2173 eh
= bfd_get_32 (abfd
, tdata
);
2174 eh_data
= bfd_get_32 (abfd
, tdata
+ 4);
2175 fprintf (file
, "%08x ", (unsigned int) eh
);
2176 fprintf (file
, "%08x", (unsigned int) eh_data
);
2179 const char *s
= my_symbol_for_address (abfd
, eh
, &cache
);
2182 fprintf (file
, " (%s) ", s
);
2189 fprintf (file
, "\n");
2194 cleanup_syms (& cache
);
2197 #undef PDATA_ROW_SIZE
2201 #define IMAGE_REL_BASED_HIGHADJ 4
2202 static const char * const tbl
[] =
2216 "UNKNOWN", /* MUST be last. */
2220 pe_print_reloc (bfd
* abfd
, void * vfile
)
2222 FILE *file
= (FILE *) vfile
;
2224 asection
*section
= bfd_get_section_by_name (abfd
, ".reloc");
2227 if (section
== NULL
|| section
->size
== 0 || !(section
->flags
& SEC_HAS_CONTENTS
))
2231 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2233 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2241 end
= data
+ section
->size
;
2242 while (p
+ 8 <= end
)
2245 bfd_vma virtual_address
;
2246 unsigned long number
, size
;
2247 bfd_byte
*chunk_end
;
2249 /* The .reloc section is a sequence of blocks, with a header consisting
2250 of two 32 bit quantities, followed by a number of 16 bit entries. */
2251 virtual_address
= bfd_get_32 (abfd
, p
);
2252 size
= bfd_get_32 (abfd
, p
+ 4);
2254 number
= (size
- 8) / 2;
2260 /* xgettext:c-format */
2261 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2262 (unsigned long) virtual_address
, size
, size
, number
);
2264 chunk_end
= p
- 8 + size
;
2265 if (chunk_end
> end
)
2268 while (p
+ 2 <= chunk_end
)
2270 unsigned short e
= bfd_get_16 (abfd
, p
);
2271 unsigned int t
= (e
& 0xF000) >> 12;
2272 int off
= e
& 0x0FFF;
2274 if (t
>= sizeof (tbl
) / sizeof (tbl
[0]))
2275 t
= (sizeof (tbl
) / sizeof (tbl
[0])) - 1;
2278 /* xgettext:c-format */
2279 _("\treloc %4d offset %4x [%4lx] %s"),
2280 j
, off
, (unsigned long) (off
+ virtual_address
), tbl
[t
]);
2285 /* HIGHADJ takes an argument, - the next record *is* the
2286 low 16 bits of addend. */
2287 if (t
== IMAGE_REL_BASED_HIGHADJ
&& p
+ 2 <= chunk_end
)
2289 fprintf (file
, " (%4x)", (unsigned int) bfd_get_16 (abfd
, p
));
2294 fprintf (file
, "\n");
2303 /* A data structure describing the regions of a .rsrc section.
2304 Some fields are filled in as the section is parsed. */
2306 typedef struct rsrc_regions
2308 bfd_byte
* section_start
;
2309 bfd_byte
* section_end
;
2310 bfd_byte
* strings_start
;
2311 bfd_byte
* resource_start
;
2315 rsrc_print_resource_directory (FILE * , bfd
*, unsigned int, bfd_byte
*,
2316 rsrc_regions
*, bfd_vma
);
2318 /* Print the resource entry at DATA, with the text indented by INDENT.
2319 Recusively calls rsrc_print_resource_directory to print the contents
2320 of directory entries.
2321 Returns the address of the end of the data associated with the entry
2322 or section_end + 1 upon failure. */
2325 rsrc_print_resource_entries (FILE * file
,
2327 unsigned int indent
,
2328 bfd_boolean is_name
,
2330 rsrc_regions
* regions
,
2333 unsigned long entry
, addr
, size
;
2336 if (data
+ 8 >= regions
->section_end
)
2337 return regions
->section_end
+ 1;
2339 /* xgettext:c-format */
2340 fprintf (file
, _("%03x %*.s Entry: "), (int)(data
- regions
->section_start
), indent
, " ");
2342 entry
= (unsigned long) bfd_get_32 (abfd
, data
);
2347 /* Note - the documentation says that this field is an RVA value
2348 but windres appears to produce a section relative offset with
2349 the top bit set. Support both styles for now. */
2350 if (HighBitSet (entry
))
2351 name
= regions
->section_start
+ WithoutHighBit (entry
);
2353 name
= regions
->section_start
+ entry
- rva_bias
;
2355 if (name
+ 2 < regions
->section_end
&& name
> regions
->section_start
)
2359 if (regions
->strings_start
== NULL
)
2360 regions
->strings_start
= name
;
2362 len
= bfd_get_16 (abfd
, name
);
2364 fprintf (file
, _("name: [val: %08lx len %d]: "), entry
, len
);
2366 if (name
+ 2 + len
* 2 < regions
->section_end
)
2368 /* This strange loop is to cope with multibyte characters. */
2375 /* Avoid printing control characters. */
2376 if (c
> 0 && c
< 32)
2377 fprintf (file
, "^%c", c
+ 64);
2379 fprintf (file
, "%.1s", name
);
2384 fprintf (file
, _("<corrupt string length: %#x>\n"), len
);
2385 /* PR binutils/17512: Do not try to continue decoding a
2386 corrupted resource section. It is likely to end up with
2387 reams of extraneous output. FIXME: We could probably
2388 continue if we disable the printing of strings... */
2389 return regions
->section_end
+ 1;
2394 fprintf (file
, _("<corrupt string offset: %#lx>\n"), entry
);
2395 return regions
->section_end
+ 1;
2399 fprintf (file
, _("ID: %#08lx"), entry
);
2401 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
2402 fprintf (file
, _(", Value: %#08lx\n"), entry
);
2404 if (HighBitSet (entry
))
2406 data
= regions
->section_start
+ WithoutHighBit (entry
);
2407 if (data
<= regions
->section_start
|| data
> regions
->section_end
)
2408 return regions
->section_end
+ 1;
2410 /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2411 in the resource table. We need some way to detect this. */
2412 return rsrc_print_resource_directory (file
, abfd
, indent
+ 1, data
,
2416 leaf
= regions
->section_start
+ entry
;
2418 if (leaf
+ 16 >= regions
->section_end
2419 /* PR 17512: file: 055dff7e. */
2420 || leaf
< regions
->section_start
)
2421 return regions
->section_end
+ 1;
2423 /* xgettext:c-format */
2424 fprintf (file
, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2425 (int) (entry
), indent
, " ",
2426 addr
= (long) bfd_get_32 (abfd
, leaf
),
2427 size
= (long) bfd_get_32 (abfd
, leaf
+ 4),
2428 (int) bfd_get_32 (abfd
, leaf
+ 8));
2430 /* Check that the reserved entry is 0. */
2431 if (bfd_get_32 (abfd
, leaf
+ 12) != 0
2432 /* And that the data address/size is valid too. */
2433 || (regions
->section_start
+ (addr
- rva_bias
) + size
> regions
->section_end
))
2434 return regions
->section_end
+ 1;
2436 if (regions
->resource_start
== NULL
)
2437 regions
->resource_start
= regions
->section_start
+ (addr
- rva_bias
);
2439 return regions
->section_start
+ (addr
- rva_bias
) + size
;
2442 #define max(a,b) ((a) > (b) ? (a) : (b))
2443 #define min(a,b) ((a) < (b) ? (a) : (b))
2446 rsrc_print_resource_directory (FILE * file
,
2448 unsigned int indent
,
2450 rsrc_regions
* regions
,
2453 unsigned int num_names
, num_ids
;
2454 bfd_byte
* highest_data
= data
;
2456 if (data
+ 16 >= regions
->section_end
)
2457 return regions
->section_end
+ 1;
2459 fprintf (file
, "%03x %*.s ", (int)(data
- regions
->section_start
), indent
, " ");
2462 case 0: fprintf (file
, "Type"); break;
2463 case 2: fprintf (file
, "Name"); break;
2464 case 4: fprintf (file
, "Language"); break;
2466 fprintf (file
, _("<unknown directory type: %d>\n"), indent
);
2467 /* FIXME: For now we end the printing here. If in the
2468 future more directory types are added to the RSRC spec
2469 then we will need to change this. */
2470 return regions
->section_end
+ 1;
2473 /* xgettext:c-format */
2474 fprintf (file
, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2475 (int) bfd_get_32 (abfd
, data
),
2476 (long) bfd_get_32 (abfd
, data
+ 4),
2477 (int) bfd_get_16 (abfd
, data
+ 8),
2478 (int) bfd_get_16 (abfd
, data
+ 10),
2479 num_names
= (int) bfd_get_16 (abfd
, data
+ 12),
2480 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14));
2483 while (num_names
--)
2485 bfd_byte
* entry_end
;
2487 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, TRUE
,
2488 data
, regions
, rva_bias
);
2490 highest_data
= max (highest_data
, entry_end
);
2491 if (entry_end
>= regions
->section_end
)
2497 bfd_byte
* entry_end
;
2499 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, FALSE
,
2500 data
, regions
, rva_bias
);
2502 highest_data
= max (highest_data
, entry_end
);
2503 if (entry_end
>= regions
->section_end
)
2507 return max (highest_data
, data
);
2510 /* Display the contents of a .rsrc section. We do not try to
2511 reproduce the resources, windres does that. Instead we dump
2512 the tables in a human readable format. */
2515 rsrc_print_section (bfd
* abfd
, void * vfile
)
2519 FILE * file
= (FILE *) vfile
;
2520 bfd_size_type datasize
;
2523 rsrc_regions regions
;
2525 pe
= pe_data (abfd
);
2529 section
= bfd_get_section_by_name (abfd
, ".rsrc");
2530 if (section
== NULL
)
2532 if (!(section
->flags
& SEC_HAS_CONTENTS
))
2535 datasize
= section
->size
;
2539 rva_bias
= section
->vma
- pe
->pe_opthdr
.ImageBase
;
2541 if (! bfd_malloc_and_get_section (abfd
, section
, & data
))
2548 regions
.section_start
= data
;
2549 regions
.section_end
= data
+ datasize
;
2550 regions
.strings_start
= NULL
;
2551 regions
.resource_start
= NULL
;
2554 fprintf (file
, "\nThe .rsrc Resource Directory section:\n");
2556 while (data
< regions
.section_end
)
2558 bfd_byte
* p
= data
;
2560 data
= rsrc_print_resource_directory (file
, abfd
, 0, data
, & regions
, rva_bias
);
2562 if (data
== regions
.section_end
+ 1)
2563 fprintf (file
, _("Corrupt .rsrc section detected!\n"));
2566 /* Align data before continuing. */
2567 int align
= (1 << section
->alignment_power
) - 1;
2569 data
= (bfd_byte
*) (((ptrdiff_t) (data
+ align
)) & ~ align
);
2570 rva_bias
+= data
- p
;
2572 /* For reasons that are unclear .rsrc sections are sometimes created
2573 aligned to a 1^3 boundary even when their alignment is set at
2574 1^2. Catch that case here before we issue a spurious warning
2576 if (data
== (regions
.section_end
- 4))
2577 data
= regions
.section_end
;
2578 else if (data
< regions
.section_end
)
2580 /* If the extra data is all zeros then do not complain.
2581 This is just padding so that the section meets the
2582 page size requirements. */
2583 while (++ data
< regions
.section_end
)
2586 if (data
< regions
.section_end
)
2587 fprintf (file
, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2592 if (regions
.strings_start
!= NULL
)
2593 fprintf (file
, _(" String table starts at offset: %#03x\n"),
2594 (int) (regions
.strings_start
- regions
.section_start
));
2595 if (regions
.resource_start
!= NULL
)
2596 fprintf (file
, _(" Resources start at offset: %#03x\n"),
2597 (int) (regions
.resource_start
- regions
.section_start
));
2599 free (regions
.section_start
);
2603 #define IMAGE_NUMBEROF_DEBUG_TYPES 12
2605 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
))
2688 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2690 const char *type_name
;
2691 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2692 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2693 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2695 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2697 if ((idd
.Type
) >= IMAGE_NUMBEROF_DEBUG_TYPES
)
2698 type_name
= debug_type_names
[0];
2700 type_name
= debug_type_names
[idd
.Type
];
2702 fprintf (file
, " %2ld %14s %08lx %08lx %08lx\n",
2703 idd
.Type
, type_name
, idd
.SizeOfData
,
2704 idd
.AddressOfRawData
, idd
.PointerToRawData
);
2706 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_CODEVIEW
)
2708 char signature
[CV_INFO_SIGNATURE_LENGTH
* 2 + 1];
2709 /* PR 17512: file: 065-29434-0.001:0.1
2710 We need to use a 32-bit aligned buffer
2711 to safely read in a codeview record. */
2712 char buffer
[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO
);
2714 CODEVIEW_INFO
*cvinfo
= (CODEVIEW_INFO
*) buffer
;
2716 /* The debug entry doesn't have to have to be in a section,
2717 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2718 if (!_bfd_XXi_slurp_codeview_record (abfd
, (file_ptr
) idd
.PointerToRawData
,
2719 idd
.SizeOfData
, cvinfo
))
2722 for (i
= 0; i
< cvinfo
->SignatureLength
; i
++)
2723 sprintf (&signature
[i
*2], "%02x", cvinfo
->Signature
[i
] & 0xff);
2725 /* xgettext:c-format */
2726 fprintf (file
, _("(format %c%c%c%c signature %s age %ld)\n"),
2727 buffer
[0], buffer
[1], buffer
[2], buffer
[3],
2728 signature
, cvinfo
->Age
);
2732 if (size
% sizeof (struct external_IMAGE_DEBUG_DIRECTORY
) != 0)
2734 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2739 /* Print out the program headers. */
2742 _bfd_XX_print_private_bfd_data_common (bfd
* abfd
, void * vfile
)
2744 FILE *file
= (FILE *) vfile
;
2746 pe_data_type
*pe
= pe_data (abfd
);
2747 struct internal_extra_pe_aouthdr
*i
= &pe
->pe_opthdr
;
2748 const char *subsystem_name
= NULL
;
2751 /* The MS dumpbin program reportedly ands with 0xff0f before
2752 printing the characteristics field. Not sure why. No reason to
2754 fprintf (file
, _("\nCharacteristics 0x%x\n"), pe
->real_flags
);
2756 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2757 PF (IMAGE_FILE_RELOCS_STRIPPED
, "relocations stripped");
2758 PF (IMAGE_FILE_EXECUTABLE_IMAGE
, "executable");
2759 PF (IMAGE_FILE_LINE_NUMS_STRIPPED
, "line numbers stripped");
2760 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED
, "symbols stripped");
2761 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE
, "large address aware");
2762 PF (IMAGE_FILE_BYTES_REVERSED_LO
, "little endian");
2763 PF (IMAGE_FILE_32BIT_MACHINE
, "32 bit words");
2764 PF (IMAGE_FILE_DEBUG_STRIPPED
, "debugging information removed");
2765 PF (IMAGE_FILE_SYSTEM
, "system file");
2766 PF (IMAGE_FILE_DLL
, "DLL");
2767 PF (IMAGE_FILE_BYTES_REVERSED_HI
, "big endian");
2770 /* ctime implies '\n'. */
2772 time_t t
= pe
->coff
.timestamp
;
2773 fprintf (file
, "\nTime/Date\t\t%s", ctime (&t
));
2776 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2777 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2779 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2780 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2782 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2783 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2788 case IMAGE_NT_OPTIONAL_HDR_MAGIC
:
2791 case IMAGE_NT_OPTIONAL_HDR64_MAGIC
:
2794 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC
:
2801 fprintf (file
, "Magic\t\t\t%04x", i
->Magic
);
2803 fprintf (file
, "\t(%s)",name
);
2804 fprintf (file
, "\nMajorLinkerVersion\t%d\n", i
->MajorLinkerVersion
);
2805 fprintf (file
, "MinorLinkerVersion\t%d\n", i
->MinorLinkerVersion
);
2806 fprintf (file
, "SizeOfCode\t\t");
2807 bfd_fprintf_vma (abfd
, file
, i
->SizeOfCode
);
2808 fprintf (file
, "\nSizeOfInitializedData\t");
2809 bfd_fprintf_vma (abfd
, file
, i
->SizeOfInitializedData
);
2810 fprintf (file
, "\nSizeOfUninitializedData\t");
2811 bfd_fprintf_vma (abfd
, file
, i
->SizeOfUninitializedData
);
2812 fprintf (file
, "\nAddressOfEntryPoint\t");
2813 bfd_fprintf_vma (abfd
, file
, i
->AddressOfEntryPoint
);
2814 fprintf (file
, "\nBaseOfCode\t\t");
2815 bfd_fprintf_vma (abfd
, file
, i
->BaseOfCode
);
2816 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2817 /* PE32+ does not have BaseOfData member! */
2818 fprintf (file
, "\nBaseOfData\t\t");
2819 bfd_fprintf_vma (abfd
, file
, i
->BaseOfData
);
2822 fprintf (file
, "\nImageBase\t\t");
2823 bfd_fprintf_vma (abfd
, file
, i
->ImageBase
);
2824 fprintf (file
, "\nSectionAlignment\t%08x\n", i
->SectionAlignment
);
2825 fprintf (file
, "FileAlignment\t\t%08x\n", i
->FileAlignment
);
2826 fprintf (file
, "MajorOSystemVersion\t%d\n", i
->MajorOperatingSystemVersion
);
2827 fprintf (file
, "MinorOSystemVersion\t%d\n", i
->MinorOperatingSystemVersion
);
2828 fprintf (file
, "MajorImageVersion\t%d\n", i
->MajorImageVersion
);
2829 fprintf (file
, "MinorImageVersion\t%d\n", i
->MinorImageVersion
);
2830 fprintf (file
, "MajorSubsystemVersion\t%d\n", i
->MajorSubsystemVersion
);
2831 fprintf (file
, "MinorSubsystemVersion\t%d\n", i
->MinorSubsystemVersion
);
2832 fprintf (file
, "Win32Version\t\t%08x\n", i
->Reserved1
);
2833 fprintf (file
, "SizeOfImage\t\t%08x\n", i
->SizeOfImage
);
2834 fprintf (file
, "SizeOfHeaders\t\t%08x\n", i
->SizeOfHeaders
);
2835 fprintf (file
, "CheckSum\t\t%08x\n", i
->CheckSum
);
2837 switch (i
->Subsystem
)
2839 case IMAGE_SUBSYSTEM_UNKNOWN
:
2840 subsystem_name
= "unspecified";
2842 case IMAGE_SUBSYSTEM_NATIVE
:
2843 subsystem_name
= "NT native";
2845 case IMAGE_SUBSYSTEM_WINDOWS_GUI
:
2846 subsystem_name
= "Windows GUI";
2848 case IMAGE_SUBSYSTEM_WINDOWS_CUI
:
2849 subsystem_name
= "Windows CUI";
2851 case IMAGE_SUBSYSTEM_POSIX_CUI
:
2852 subsystem_name
= "POSIX CUI";
2854 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI
:
2855 subsystem_name
= "Wince CUI";
2857 // These are from UEFI Platform Initialization Specification 1.1.
2858 case IMAGE_SUBSYSTEM_EFI_APPLICATION
:
2859 subsystem_name
= "EFI application";
2861 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
:
2862 subsystem_name
= "EFI boot service driver";
2864 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
:
2865 subsystem_name
= "EFI runtime driver";
2867 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER
:
2868 subsystem_name
= "SAL runtime driver";
2870 // This is from revision 8.0 of the MS PE/COFF spec
2871 case IMAGE_SUBSYSTEM_XBOX
:
2872 subsystem_name
= "XBOX";
2874 // Added default case for clarity - subsystem_name is NULL anyway.
2876 subsystem_name
= NULL
;
2879 fprintf (file
, "Subsystem\t\t%08x", i
->Subsystem
);
2881 fprintf (file
, "\t(%s)", subsystem_name
);
2882 fprintf (file
, "\nDllCharacteristics\t%08x\n", i
->DllCharacteristics
);
2883 fprintf (file
, "SizeOfStackReserve\t");
2884 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackReserve
);
2885 fprintf (file
, "\nSizeOfStackCommit\t");
2886 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackCommit
);
2887 fprintf (file
, "\nSizeOfHeapReserve\t");
2888 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapReserve
);
2889 fprintf (file
, "\nSizeOfHeapCommit\t");
2890 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapCommit
);
2891 fprintf (file
, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i
->LoaderFlags
);
2892 fprintf (file
, "NumberOfRvaAndSizes\t%08lx\n",
2893 (unsigned long) i
->NumberOfRvaAndSizes
);
2895 fprintf (file
, "\nThe Data Directory\n");
2896 for (j
= 0; j
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; j
++)
2898 fprintf (file
, "Entry %1x ", j
);
2899 bfd_fprintf_vma (abfd
, file
, i
->DataDirectory
[j
].VirtualAddress
);
2900 fprintf (file
, " %08lx ", (unsigned long) i
->DataDirectory
[j
].Size
);
2901 fprintf (file
, "%s\n", dir_names
[j
]);
2904 pe_print_idata (abfd
, vfile
);
2905 pe_print_edata (abfd
, vfile
);
2906 if (bfd_coff_have_print_pdata (abfd
))
2907 bfd_coff_print_pdata (abfd
, vfile
);
2909 pe_print_pdata (abfd
, vfile
);
2910 pe_print_reloc (abfd
, vfile
);
2911 pe_print_debugdata (abfd
, file
);
2913 rsrc_print_section (abfd
, vfile
);
2919 is_vma_in_section (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sect
, void *obj
)
2921 bfd_vma addr
= * (bfd_vma
*) obj
;
2922 return (addr
>= sect
->vma
) && (addr
< (sect
->vma
+ sect
->size
));
2926 find_section_by_vma (bfd
*abfd
, bfd_vma addr
)
2928 return bfd_sections_find_if (abfd
, is_vma_in_section
, (void *) & addr
);
2931 /* Copy any private info we understand from the input bfd
2932 to the output bfd. */
2935 _bfd_XX_bfd_copy_private_bfd_data_common (bfd
* ibfd
, bfd
* obfd
)
2937 pe_data_type
*ipe
, *ope
;
2939 /* One day we may try to grok other private data. */
2940 if (ibfd
->xvec
->flavour
!= bfd_target_coff_flavour
2941 || obfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
2944 ipe
= pe_data (ibfd
);
2945 ope
= pe_data (obfd
);
2947 /* pe_opthdr is copied in copy_object. */
2948 ope
->dll
= ipe
->dll
;
2950 /* Don't copy input subsystem if output is different from input. */
2951 if (obfd
->xvec
!= ibfd
->xvec
)
2952 ope
->pe_opthdr
.Subsystem
= IMAGE_SUBSYSTEM_UNKNOWN
;
2954 /* For strip: if we removed .reloc, we'll make a real mess of things
2955 if we don't remove this entry as well. */
2956 if (! pe_data (obfd
)->has_reloc_section
)
2958 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].VirtualAddress
= 0;
2959 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].Size
= 0;
2962 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2963 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2965 if (! pe_data (ibfd
)->has_reloc_section
2966 && ! (pe_data (ibfd
)->real_flags
& IMAGE_FILE_RELOCS_STRIPPED
))
2967 pe_data (obfd
)->dont_strip_reloc
= 1;
2969 memcpy (ope
->dos_message
, ipe
->dos_message
, sizeof (ope
->dos_message
));
2971 /* The file offsets contained in the debug directory need rewriting. */
2972 if (ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
!= 0)
2974 bfd_vma addr
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
2975 + ope
->pe_opthdr
.ImageBase
;
2976 asection
*section
= find_section_by_vma (obfd
, addr
);
2979 if (section
&& bfd_malloc_and_get_section (obfd
, section
, &data
))
2982 struct external_IMAGE_DEBUG_DIRECTORY
*dd
=
2983 (struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ (addr
- section
->vma
));
2985 /* PR 17512: file: 0f15796a. */
2986 if ((unsigned long) ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
2987 > section
->size
- (addr
- section
->vma
))
2989 /* xgettext:c-format */
2991 (_("%pB: Data Directory size (%lx) "
2992 "exceeds space left in section (%" PRIx64
")"),
2993 obfd
, ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
,
2994 (uint64_t) (section
->size
- (addr
- section
->vma
)));
2999 for (i
= 0; i
< ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
3000 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
3002 asection
*ddsection
;
3003 struct external_IMAGE_DEBUG_DIRECTORY
*edd
= &(dd
[i
]);
3004 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
3006 _bfd_XXi_swap_debugdir_in (obfd
, edd
, &idd
);
3008 if (idd
.AddressOfRawData
== 0)
3009 continue; /* RVA 0 means only offset is valid, not handled yet. */
3011 ddsection
= find_section_by_vma (obfd
, idd
.AddressOfRawData
+ ope
->pe_opthdr
.ImageBase
);
3013 continue; /* Not in a section! */
3015 idd
.PointerToRawData
= ddsection
->filepos
+ (idd
.AddressOfRawData
3016 + ope
->pe_opthdr
.ImageBase
) - ddsection
->vma
;
3018 _bfd_XXi_swap_debugdir_out (obfd
, &idd
, edd
);
3021 if (!bfd_set_section_contents (obfd
, section
, data
, 0, section
->size
))
3023 _bfd_error_handler (_("failed to update file offsets in debug directory"));
3031 _bfd_error_handler (_("%pB: failed to read debug data section"), obfd
);
3039 /* Copy private section data. */
3042 _bfd_XX_bfd_copy_private_section_data (bfd
*ibfd
,
3047 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
3048 || bfd_get_flavour (obfd
) != bfd_target_coff_flavour
)
3051 if (coff_section_data (ibfd
, isec
) != NULL
3052 && pei_section_data (ibfd
, isec
) != NULL
)
3054 if (coff_section_data (obfd
, osec
) == NULL
)
3056 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
3057 osec
->used_by_bfd
= bfd_zalloc (obfd
, amt
);
3058 if (osec
->used_by_bfd
== NULL
)
3062 if (pei_section_data (obfd
, osec
) == NULL
)
3064 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
3065 coff_section_data (obfd
, osec
)->tdata
= bfd_zalloc (obfd
, amt
);
3066 if (coff_section_data (obfd
, osec
)->tdata
== NULL
)
3070 pei_section_data (obfd
, osec
)->virt_size
=
3071 pei_section_data (ibfd
, isec
)->virt_size
;
3072 pei_section_data (obfd
, osec
)->pe_flags
=
3073 pei_section_data (ibfd
, isec
)->pe_flags
;
3080 _bfd_XX_get_symbol_info (bfd
* abfd
, asymbol
*symbol
, symbol_info
*ret
)
3082 coff_get_symbol_info (abfd
, symbol
, ret
);
3085 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
3087 sort_x64_pdata (const void *l
, const void *r
)
3089 const char *lp
= (const char *) l
;
3090 const char *rp
= (const char *) r
;
3092 vl
= bfd_getl32 (lp
); vr
= bfd_getl32 (rp
);
3094 return (vl
< vr
? -1 : 1);
3095 /* We compare just begin address. */
3100 /* Functions to process a .rsrc section. */
3102 static unsigned int sizeof_leaves
;
3103 static unsigned int sizeof_strings
;
3104 static unsigned int sizeof_tables_and_entries
;
3107 rsrc_count_directory (bfd
*, bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
3110 rsrc_count_entries (bfd
* abfd
,
3111 bfd_boolean is_name
,
3112 bfd_byte
* datastart
,
3117 unsigned long entry
, addr
, size
;
3119 if (data
+ 8 >= dataend
)
3126 entry
= (long) bfd_get_32 (abfd
, data
);
3128 if (HighBitSet (entry
))
3129 name
= datastart
+ WithoutHighBit (entry
);
3131 name
= datastart
+ entry
- rva_bias
;
3133 if (name
+ 2 >= dataend
|| name
< datastart
)
3136 unsigned int len
= bfd_get_16 (abfd
, name
);
3137 if (len
== 0 || len
> 256)
3141 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
3143 if (HighBitSet (entry
))
3145 data
= datastart
+ WithoutHighBit (entry
);
3147 if (data
<= datastart
|| data
>= dataend
)
3150 return rsrc_count_directory (abfd
, datastart
, data
, dataend
, rva_bias
);
3153 if (datastart
+ entry
+ 16 >= dataend
)
3156 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
);
3157 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4);
3159 return datastart
+ addr
- rva_bias
+ size
;
3163 rsrc_count_directory (bfd
* abfd
,
3164 bfd_byte
* datastart
,
3169 unsigned int num_entries
, num_ids
;
3170 bfd_byte
* highest_data
= data
;
3172 if (data
+ 16 >= dataend
)
3175 num_entries
= (int) bfd_get_16 (abfd
, data
+ 12);
3176 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14);
3178 num_entries
+= num_ids
;
3182 while (num_entries
--)
3184 bfd_byte
* entry_end
;
3186 entry_end
= rsrc_count_entries (abfd
, num_entries
>= num_ids
,
3187 datastart
, data
, dataend
, rva_bias
);
3189 highest_data
= max (highest_data
, entry_end
);
3190 if (entry_end
>= dataend
)
3194 return max (highest_data
, data
);
3197 typedef struct rsrc_dir_chain
3199 unsigned int num_entries
;
3200 struct rsrc_entry
* first_entry
;
3201 struct rsrc_entry
* last_entry
;
3204 typedef struct rsrc_directory
3206 unsigned int characteristics
;
3211 rsrc_dir_chain names
;
3214 struct rsrc_entry
* entry
;
3217 typedef struct rsrc_string
3223 typedef struct rsrc_leaf
3226 unsigned int codepage
;
3230 typedef struct rsrc_entry
3232 bfd_boolean is_name
;
3236 struct rsrc_string name
;
3242 struct rsrc_directory
* directory
;
3243 struct rsrc_leaf
* leaf
;
3246 struct rsrc_entry
* next_entry
;
3247 struct rsrc_directory
* parent
;
3251 rsrc_parse_directory (bfd
*, rsrc_directory
*, bfd_byte
*,
3252 bfd_byte
*, bfd_byte
*, bfd_vma
, rsrc_entry
*);
3255 rsrc_parse_entry (bfd
* abfd
,
3256 bfd_boolean is_name
,
3258 bfd_byte
* datastart
,
3262 rsrc_directory
* parent
)
3264 unsigned long val
, addr
, size
;
3266 val
= bfd_get_32 (abfd
, data
);
3268 entry
->parent
= parent
;
3269 entry
->is_name
= is_name
;
3275 if (HighBitSet (val
))
3277 val
= WithoutHighBit (val
);
3279 address
= datastart
+ val
;
3283 address
= datastart
+ val
- rva_bias
;
3286 if (address
+ 3 > dataend
)
3289 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, address
);
3290 entry
->name_id
.name
.string
= address
+ 2;
3293 entry
->name_id
.id
= val
;
3295 val
= bfd_get_32 (abfd
, data
+ 4);
3297 if (HighBitSet (val
))
3299 entry
->is_dir
= TRUE
;
3300 entry
->value
.directory
= bfd_malloc (sizeof * entry
->value
.directory
);
3301 if (entry
->value
.directory
== NULL
)
3304 return rsrc_parse_directory (abfd
, entry
->value
.directory
,
3306 datastart
+ WithoutHighBit (val
),
3307 dataend
, rva_bias
, entry
);
3310 entry
->is_dir
= FALSE
;
3311 entry
->value
.leaf
= bfd_malloc (sizeof * entry
->value
.leaf
);
3312 if (entry
->value
.leaf
== NULL
)
3315 data
= datastart
+ val
;
3316 if (data
< datastart
|| data
>= dataend
)
3319 addr
= bfd_get_32 (abfd
, data
);
3320 size
= entry
->value
.leaf
->size
= bfd_get_32 (abfd
, data
+ 4);
3321 entry
->value
.leaf
->codepage
= bfd_get_32 (abfd
, data
+ 8);
3322 /* FIXME: We assume that the reserved field (data + 12) is OK. */
3324 entry
->value
.leaf
->data
= bfd_malloc (size
);
3325 if (entry
->value
.leaf
->data
== NULL
)
3328 memcpy (entry
->value
.leaf
->data
, datastart
+ addr
- rva_bias
, size
);
3329 return datastart
+ (addr
- rva_bias
) + size
;
3333 rsrc_parse_entries (bfd
* abfd
,
3334 rsrc_dir_chain
* chain
,
3335 bfd_boolean is_name
,
3336 bfd_byte
* highest_data
,
3337 bfd_byte
* datastart
,
3341 rsrc_directory
* parent
)
3346 if (chain
->num_entries
== 0)
3348 chain
->first_entry
= chain
->last_entry
= NULL
;
3349 return highest_data
;
3352 entry
= bfd_malloc (sizeof * entry
);
3356 chain
->first_entry
= entry
;
3358 for (i
= chain
->num_entries
; i
--;)
3360 bfd_byte
* entry_end
;
3362 entry_end
= rsrc_parse_entry (abfd
, is_name
, entry
, datastart
,
3363 data
, dataend
, rva_bias
, parent
);
3365 highest_data
= max (entry_end
, highest_data
);
3366 if (entry_end
> dataend
)
3371 entry
->next_entry
= bfd_malloc (sizeof * entry
);
3372 entry
= entry
->next_entry
;
3377 entry
->next_entry
= NULL
;
3380 chain
->last_entry
= entry
;
3382 return highest_data
;
3386 rsrc_parse_directory (bfd
* abfd
,
3387 rsrc_directory
* table
,
3388 bfd_byte
* datastart
,
3394 bfd_byte
* highest_data
= data
;
3399 table
->characteristics
= bfd_get_32 (abfd
, data
);
3400 table
->time
= bfd_get_32 (abfd
, data
+ 4);
3401 table
->major
= bfd_get_16 (abfd
, data
+ 8);
3402 table
->minor
= bfd_get_16 (abfd
, data
+ 10);
3403 table
->names
.num_entries
= bfd_get_16 (abfd
, data
+ 12);
3404 table
->ids
.num_entries
= bfd_get_16 (abfd
, data
+ 14);
3405 table
->entry
= entry
;
3409 highest_data
= rsrc_parse_entries (abfd
, & table
->names
, TRUE
, data
,
3410 datastart
, data
, dataend
, rva_bias
, table
);
3411 data
+= table
->names
.num_entries
* 8;
3413 highest_data
= rsrc_parse_entries (abfd
, & table
->ids
, FALSE
, highest_data
,
3414 datastart
, data
, dataend
, rva_bias
, table
);
3415 data
+= table
->ids
.num_entries
* 8;
3417 return max (highest_data
, data
);
3420 typedef struct rsrc_write_data
3423 bfd_byte
* datastart
;
3424 bfd_byte
* next_table
;
3425 bfd_byte
* next_leaf
;
3426 bfd_byte
* next_string
;
3427 bfd_byte
* next_data
;
3432 rsrc_write_string (rsrc_write_data
* data
,
3433 rsrc_string
* string
)
3435 bfd_put_16 (data
->abfd
, string
->len
, data
->next_string
);
3436 memcpy (data
->next_string
+ 2, string
->string
, string
->len
* 2);
3437 data
->next_string
+= (string
->len
+ 1) * 2;
3440 static inline unsigned int
3441 rsrc_compute_rva (rsrc_write_data
* data
,
3444 return (addr
- data
->datastart
) + data
->rva_bias
;
3448 rsrc_write_leaf (rsrc_write_data
* data
,
3451 bfd_put_32 (data
->abfd
, rsrc_compute_rva (data
, data
->next_data
),
3453 bfd_put_32 (data
->abfd
, leaf
->size
, data
->next_leaf
+ 4);
3454 bfd_put_32 (data
->abfd
, leaf
->codepage
, data
->next_leaf
+ 8);
3455 bfd_put_32 (data
->abfd
, 0 /*reserved*/, data
->next_leaf
+ 12);
3456 data
->next_leaf
+= 16;
3458 memcpy (data
->next_data
, leaf
->data
, leaf
->size
);
3459 /* An undocumented feature of Windows resources is that each unit
3460 of raw data is 8-byte aligned... */
3461 data
->next_data
+= ((leaf
->size
+ 7) & ~7);
3464 static void rsrc_write_directory (rsrc_write_data
*, rsrc_directory
*);
3467 rsrc_write_entry (rsrc_write_data
* data
,
3473 bfd_put_32 (data
->abfd
,
3474 SetHighBit (data
->next_string
- data
->datastart
),
3476 rsrc_write_string (data
, & entry
->name_id
.name
);
3479 bfd_put_32 (data
->abfd
, entry
->name_id
.id
, where
);
3483 bfd_put_32 (data
->abfd
,
3484 SetHighBit (data
->next_table
- data
->datastart
),
3486 rsrc_write_directory (data
, entry
->value
.directory
);
3490 bfd_put_32 (data
->abfd
, data
->next_leaf
- data
->datastart
, where
+ 4);
3491 rsrc_write_leaf (data
, entry
->value
.leaf
);
3496 rsrc_compute_region_sizes (rsrc_directory
* dir
)
3498 struct rsrc_entry
* entry
;
3503 sizeof_tables_and_entries
+= 16;
3505 for (entry
= dir
->names
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3507 sizeof_tables_and_entries
+= 8;
3509 sizeof_strings
+= (entry
->name_id
.name
.len
+ 1) * 2;
3512 rsrc_compute_region_sizes (entry
->value
.directory
);
3514 sizeof_leaves
+= 16;
3517 for (entry
= dir
->ids
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3519 sizeof_tables_and_entries
+= 8;
3522 rsrc_compute_region_sizes (entry
->value
.directory
);
3524 sizeof_leaves
+= 16;
3529 rsrc_write_directory (rsrc_write_data
* data
,
3530 rsrc_directory
* dir
)
3534 bfd_byte
* next_entry
;
3537 bfd_put_32 (data
->abfd
, dir
->characteristics
, data
->next_table
);
3538 bfd_put_32 (data
->abfd
, 0 /*dir->time*/, data
->next_table
+ 4);
3539 bfd_put_16 (data
->abfd
, dir
->major
, data
->next_table
+ 8);
3540 bfd_put_16 (data
->abfd
, dir
->minor
, data
->next_table
+ 10);
3541 bfd_put_16 (data
->abfd
, dir
->names
.num_entries
, data
->next_table
+ 12);
3542 bfd_put_16 (data
->abfd
, dir
->ids
.num_entries
, data
->next_table
+ 14);
3544 /* Compute where the entries and the next table will be placed. */
3545 next_entry
= data
->next_table
+ 16;
3546 data
->next_table
= next_entry
+ (dir
->names
.num_entries
* 8)
3547 + (dir
->ids
.num_entries
* 8);
3548 nt
= data
->next_table
;
3550 /* Write the entries. */
3551 for (i
= dir
->names
.num_entries
, entry
= dir
->names
.first_entry
;
3552 i
> 0 && entry
!= NULL
;
3553 i
--, entry
= entry
->next_entry
)
3555 BFD_ASSERT (entry
->is_name
);
3556 rsrc_write_entry (data
, next_entry
, entry
);
3559 BFD_ASSERT (i
== 0);
3560 BFD_ASSERT (entry
== NULL
);
3562 for (i
= dir
->ids
.num_entries
, entry
= dir
->ids
.first_entry
;
3563 i
> 0 && entry
!= NULL
;
3564 i
--, entry
= entry
->next_entry
)
3566 BFD_ASSERT (! entry
->is_name
);
3567 rsrc_write_entry (data
, next_entry
, entry
);
3570 BFD_ASSERT (i
== 0);
3571 BFD_ASSERT (entry
== NULL
);
3572 BFD_ASSERT (nt
== next_entry
);
3575 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3576 /* Return the length (number of units) of the first character in S,
3577 putting its 'ucs4_t' representation in *PUC. */
3580 #if defined HAVE_WCTYPE_H
3581 u16_mbtouc (wint_t * puc
, const unsigned short * s
, unsigned int n
)
3583 u16_mbtouc (wchar_t * puc
, const unsigned short * s
, unsigned int n
)
3586 unsigned short c
= * s
;
3588 if (c
< 0xd800 || c
>= 0xe000)
3598 if (s
[1] >= 0xdc00 && s
[1] < 0xe000)
3600 *puc
= 0x10000 + ((c
- 0xd800) << 10) + (s
[1] - 0xdc00);
3606 /* Incomplete multibyte character. */
3612 /* Invalid multibyte character. */
3616 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3618 /* Perform a comparison of two entries. */
3620 rsrc_cmp (bfd_boolean is_name
, rsrc_entry
* a
, rsrc_entry
* b
)
3629 return a
->name_id
.id
- b
->name_id
.id
;
3631 /* We have to perform a case insenstive, unicode string comparison... */
3632 astring
= a
->name_id
.name
.string
;
3633 alen
= a
->name_id
.name
.len
;
3634 bstring
= b
->name_id
.name
.string
;
3635 blen
= b
->name_id
.name
.len
;
3637 #if defined __CYGWIN__ || defined __MINGW32__
3638 /* Under Windows hosts (both Cygwin and Mingw types),
3639 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3640 function however goes by different names in the two environments... */
3644 #define rscpcmp wcsncasecmp
3647 #define rscpcmp wcsnicmp
3650 res
= rscpcmp ((const wchar_t *) astring
, (const wchar_t *) bstring
,
3653 #elif defined HAVE_WCHAR_H
3658 for (i
= min (alen
, blen
); i
--; astring
+= 2, bstring
+= 2)
3660 #if defined HAVE_WCTYPE_H
3668 /* Convert UTF-16 unicode characters into wchar_t characters
3669 so that we can then perform a case insensitive comparison. */
3670 unsigned int Alen
= u16_mbtouc (& awc
, (const unsigned short *) astring
, 2);
3671 unsigned int Blen
= u16_mbtouc (& bwc
, (const unsigned short *) bstring
, 2);
3676 #ifdef HAVE_WCTYPE_H
3677 awc
= towlower (awc
);
3678 bwc
= towlower (bwc
);
3682 res
= wcsncasecmp (& awc
, & bwc
, 1);
3689 /* Do the best we can - a case sensitive, untranslated comparison. */
3690 res
= memcmp (astring
, bstring
, min (alen
, blen
) * 2);
3700 rsrc_print_name (char * buffer
, rsrc_string string
)
3703 bfd_byte
* name
= string
.string
;
3705 for (i
= string
.len
; i
--; name
+= 2)
3706 sprintf (buffer
+ strlen (buffer
), "%.1s", name
);
3710 rsrc_resource_name (rsrc_entry
* entry
, rsrc_directory
* dir
)
3712 static char buffer
[256];
3713 bfd_boolean is_string
= FALSE
;
3717 if (dir
!= NULL
&& dir
->entry
!= NULL
&& dir
->entry
->parent
!= NULL
3718 && dir
->entry
->parent
->entry
!= NULL
)
3720 strcpy (buffer
, "type: ");
3721 if (dir
->entry
->parent
->entry
->is_name
)
3722 rsrc_print_name (buffer
+ strlen (buffer
),
3723 dir
->entry
->parent
->entry
->name_id
.name
);
3726 unsigned int id
= dir
->entry
->parent
->entry
->name_id
.id
;
3728 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3731 case 1: strcat (buffer
, " (CURSOR)"); break;
3732 case 2: strcat (buffer
, " (BITMAP)"); break;
3733 case 3: strcat (buffer
, " (ICON)"); break;
3734 case 4: strcat (buffer
, " (MENU)"); break;
3735 case 5: strcat (buffer
, " (DIALOG)"); break;
3736 case 6: strcat (buffer
, " (STRING)"); is_string
= TRUE
; break;
3737 case 7: strcat (buffer
, " (FONTDIR)"); break;
3738 case 8: strcat (buffer
, " (FONT)"); break;
3739 case 9: strcat (buffer
, " (ACCELERATOR)"); break;
3740 case 10: strcat (buffer
, " (RCDATA)"); break;
3741 case 11: strcat (buffer
, " (MESSAGETABLE)"); break;
3742 case 12: strcat (buffer
, " (GROUP_CURSOR)"); break;
3743 case 14: strcat (buffer
, " (GROUP_ICON)"); break;
3744 case 16: strcat (buffer
, " (VERSION)"); break;
3745 case 17: strcat (buffer
, " (DLGINCLUDE)"); break;
3746 case 19: strcat (buffer
, " (PLUGPLAY)"); break;
3747 case 20: strcat (buffer
, " (VXD)"); break;
3748 case 21: strcat (buffer
, " (ANICURSOR)"); break;
3749 case 22: strcat (buffer
, " (ANIICON)"); break;
3750 case 23: strcat (buffer
, " (HTML)"); break;
3751 case 24: strcat (buffer
, " (MANIFEST)"); break;
3752 case 240: strcat (buffer
, " (DLGINIT)"); break;
3753 case 241: strcat (buffer
, " (TOOLBAR)"); break;
3758 if (dir
!= NULL
&& dir
->entry
!= NULL
)
3760 strcat (buffer
, " name: ");
3761 if (dir
->entry
->is_name
)
3762 rsrc_print_name (buffer
+ strlen (buffer
), dir
->entry
->name_id
.name
);
3765 unsigned int id
= dir
->entry
->name_id
.id
;
3767 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3770 sprintf (buffer
+ strlen (buffer
), " (resource id range: %d - %d)",
3771 (id
- 1) << 4, (id
<< 4) - 1);
3777 strcat (buffer
, " lang: ");
3780 rsrc_print_name (buffer
+ strlen (buffer
), entry
->name_id
.name
);
3782 sprintf (buffer
+ strlen (buffer
), "%x", entry
->name_id
.id
);
3788 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3789 their ID is stored in the NAME entry. The bottom four bits are used as
3790 an index into unicode string table that makes up the data of the leaf.
3791 So identical type-name-lang string resources may not actually be
3794 This function is called when we have detected two string resources with
3795 match top-28-bit IDs. We have to scan the string tables inside the leaves
3796 and discover if there are any real collisions. If there are then we report
3797 them and return FALSE. Otherwise we copy any strings from B into A and
3798 then return TRUE. */
3801 rsrc_merge_string_entries (rsrc_entry
* a ATTRIBUTE_UNUSED
,
3802 rsrc_entry
* b ATTRIBUTE_UNUSED
)
3804 unsigned int copy_needed
= 0;
3808 bfd_byte
* new_data
;
3811 /* Step one: Find out what we have to do. */
3812 BFD_ASSERT (! a
->is_dir
);
3813 astring
= a
->value
.leaf
->data
;
3815 BFD_ASSERT (! b
->is_dir
);
3816 bstring
= b
->value
.leaf
->data
;
3818 for (i
= 0; i
< 16; i
++)
3820 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3821 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3825 copy_needed
+= blen
* 2;
3829 else if (alen
!= blen
)
3830 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3832 /* alen == blen != 0. We might have two identical strings. If so we
3833 can ignore the second one. There is no need for wchar_t vs UTF-16
3834 theatrics here - we are only interested in (case sensitive) equality. */
3835 else if (memcmp (astring
+ 2, bstring
+ 2, alen
* 2) != 0)
3838 astring
+= (alen
+ 1) * 2;
3839 bstring
+= (blen
+ 1) * 2;
3844 if (a
->parent
!= NULL
3845 && a
->parent
->entry
!= NULL
3846 && !a
->parent
->entry
->is_name
)
3847 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3848 ((a
->parent
->entry
->name_id
.id
- 1) << 4) + i
);
3852 if (copy_needed
== 0)
3855 /* If we reach here then A and B must both have non-colliding strings.
3856 (We never get string resources with fully empty string tables).
3857 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3859 new_data
= bfd_malloc (a
->value
.leaf
->size
+ copy_needed
);
3860 if (new_data
== NULL
)
3864 astring
= a
->value
.leaf
->data
;
3865 bstring
= b
->value
.leaf
->data
;
3867 for (i
= 0; i
< 16; i
++)
3869 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3870 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3874 memcpy (nstring
, astring
, (alen
+ 1) * 2);
3875 nstring
+= (alen
+ 1) * 2;
3879 memcpy (nstring
, bstring
, (blen
+ 1) * 2);
3880 nstring
+= (blen
+ 1) * 2;
3888 astring
+= (alen
+ 1) * 2;
3889 bstring
+= (blen
+ 1) * 2;
3892 BFD_ASSERT (nstring
- new_data
== (signed) (a
->value
.leaf
->size
+ copy_needed
));
3894 free (a
->value
.leaf
->data
);
3895 a
->value
.leaf
->data
= new_data
;
3896 a
->value
.leaf
->size
+= copy_needed
;
3901 static void rsrc_merge (rsrc_entry
*, rsrc_entry
*);
3903 /* Sort the entries in given part of the directory.
3904 We use an old fashioned bubble sort because we are dealing
3905 with lists and we want to handle matches specially. */
3908 rsrc_sort_entries (rsrc_dir_chain
* chain
,
3909 bfd_boolean is_name
,
3910 rsrc_directory
* dir
)
3914 rsrc_entry
** points_to_entry
;
3915 bfd_boolean swapped
;
3917 if (chain
->num_entries
< 2)
3923 points_to_entry
= & chain
->first_entry
;
3924 entry
= * points_to_entry
;
3925 next
= entry
->next_entry
;
3929 signed int cmp
= rsrc_cmp (is_name
, entry
, next
);
3933 entry
->next_entry
= next
->next_entry
;
3934 next
->next_entry
= entry
;
3935 * points_to_entry
= next
;
3936 points_to_entry
= & next
->next_entry
;
3937 next
= entry
->next_entry
;
3942 if (entry
->is_dir
&& next
->is_dir
)
3944 /* When we encounter identical directory entries we have to
3945 merge them together. The exception to this rule is for
3946 resource manifests - there can only be one of these,
3947 even if they differ in language. Zero-language manifests
3948 are assumed to be default manifests (provided by the
3949 Cygwin/MinGW build system) and these can be silently dropped,
3950 unless that would reduce the number of manifests to zero.
3951 There should only ever be one non-zero lang manifest -
3952 if there are more it is an error. A non-zero lang
3953 manifest takes precedence over a default manifest. */
3955 && entry
->name_id
.id
== 1
3957 && dir
->entry
!= NULL
3958 && !dir
->entry
->is_name
3959 && dir
->entry
->name_id
.id
== 0x18)
3961 if (next
->value
.directory
->names
.num_entries
== 0
3962 && next
->value
.directory
->ids
.num_entries
== 1
3963 && !next
->value
.directory
->ids
.first_entry
->is_name
3964 && next
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3965 /* Fall through so that NEXT is dropped. */
3967 else if (entry
->value
.directory
->names
.num_entries
== 0
3968 && entry
->value
.directory
->ids
.num_entries
== 1
3969 && !entry
->value
.directory
->ids
.first_entry
->is_name
3970 && entry
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3972 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
3973 entry
->next_entry
= next
->next_entry
;
3974 next
->next_entry
= entry
;
3975 * points_to_entry
= next
;
3976 points_to_entry
= & next
->next_entry
;
3977 next
= entry
->next_entry
;
3982 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3983 bfd_set_error (bfd_error_file_truncated
);
3987 /* Unhook NEXT from the chain. */
3988 /* FIXME: memory loss here. */
3989 entry
->next_entry
= next
->next_entry
;
3990 chain
->num_entries
--;
3991 if (chain
->num_entries
< 2)
3993 next
= next
->next_entry
;
3996 rsrc_merge (entry
, next
);
3998 else if (entry
->is_dir
!= next
->is_dir
)
4000 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
4001 bfd_set_error (bfd_error_file_truncated
);
4006 /* Otherwise with identical leaves we issue an error
4007 message - because there should never be duplicates.
4008 The exception is Type 18/Name 1/Lang 0 which is the
4009 defaul manifest - this can just be dropped. */
4011 && entry
->name_id
.id
== 0
4013 && dir
->entry
!= NULL
4014 && !dir
->entry
->is_name
4015 && dir
->entry
->name_id
.id
== 1
4016 && dir
->entry
->parent
!= NULL
4017 && dir
->entry
->parent
->entry
!= NULL
4018 && !dir
->entry
->parent
->entry
->is_name
4019 && dir
->entry
->parent
->entry
->name_id
.id
== 0x18 /* RT_MANIFEST */)
4021 else if (dir
!= NULL
4022 && dir
->entry
!= NULL
4023 && dir
->entry
->parent
!= NULL
4024 && dir
->entry
->parent
->entry
!= NULL
4025 && !dir
->entry
->parent
->entry
->is_name
4026 && dir
->entry
->parent
->entry
->name_id
.id
== 0x6 /* RT_STRING */)
4028 /* Strings need special handling. */
4029 if (! rsrc_merge_string_entries (entry
, next
))
4031 /* _bfd_error_handler should have been called inside merge_strings. */
4032 bfd_set_error (bfd_error_file_truncated
);
4039 || dir
->entry
== NULL
4040 || dir
->entry
->parent
== NULL
4041 || dir
->entry
->parent
->entry
== NULL
)
4042 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
4044 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
4045 rsrc_resource_name (entry
, dir
));
4046 bfd_set_error (bfd_error_file_truncated
);
4051 /* Unhook NEXT from the chain. */
4052 entry
->next_entry
= next
->next_entry
;
4053 chain
->num_entries
--;
4054 if (chain
->num_entries
< 2)
4056 next
= next
->next_entry
;
4060 points_to_entry
= & entry
->next_entry
;
4062 next
= next
->next_entry
;
4067 chain
->last_entry
= entry
;
4072 /* Attach B's chain onto A. */
4074 rsrc_attach_chain (rsrc_dir_chain
* achain
, rsrc_dir_chain
* bchain
)
4076 if (bchain
->num_entries
== 0)
4079 achain
->num_entries
+= bchain
->num_entries
;
4081 if (achain
->first_entry
== NULL
)
4083 achain
->first_entry
= bchain
->first_entry
;
4084 achain
->last_entry
= bchain
->last_entry
;
4088 achain
->last_entry
->next_entry
= bchain
->first_entry
;
4089 achain
->last_entry
= bchain
->last_entry
;
4092 bchain
->num_entries
= 0;
4093 bchain
->first_entry
= bchain
->last_entry
= NULL
;
4097 rsrc_merge (struct rsrc_entry
* a
, struct rsrc_entry
* b
)
4099 rsrc_directory
* adir
;
4100 rsrc_directory
* bdir
;
4102 BFD_ASSERT (a
->is_dir
);
4103 BFD_ASSERT (b
->is_dir
);
4105 adir
= a
->value
.directory
;
4106 bdir
= b
->value
.directory
;
4108 if (adir
->characteristics
!= bdir
->characteristics
)
4110 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics"));
4111 bfd_set_error (bfd_error_file_truncated
);
4115 if (adir
->major
!= bdir
->major
|| adir
->minor
!= bdir
->minor
)
4117 _bfd_error_handler (_(".rsrc merge failure: differing directory versions"));
4118 bfd_set_error (bfd_error_file_truncated
);
4122 /* Attach B's name chain to A. */
4123 rsrc_attach_chain (& adir
->names
, & bdir
->names
);
4125 /* Attach B's ID chain to A. */
4126 rsrc_attach_chain (& adir
->ids
, & bdir
->ids
);
4128 /* Now sort A's entries. */
4129 rsrc_sort_entries (& adir
->names
, TRUE
, adir
);
4130 rsrc_sort_entries (& adir
->ids
, FALSE
, adir
);
4133 /* Check the .rsrc section. If it contains multiple concatenated
4134 resources then we must merge them properly. Otherwise Windows
4135 will ignore all but the first set. */
4138 rsrc_process_section (bfd
* abfd
,
4139 struct coff_final_link_info
* pfinfo
)
4141 rsrc_directory new_table
;
4147 bfd_byte
* datastart
;
4149 bfd_byte
* new_data
;
4150 unsigned int num_resource_sets
;
4151 rsrc_directory
* type_tables
;
4152 rsrc_write_data write_data
;
4155 unsigned int num_input_rsrc
= 0;
4156 unsigned int max_num_input_rsrc
= 4;
4157 ptrdiff_t * rsrc_sizes
= NULL
;
4159 new_table
.names
.num_entries
= 0;
4160 new_table
.ids
.num_entries
= 0;
4162 sec
= bfd_get_section_by_name (abfd
, ".rsrc");
4163 if (sec
== NULL
|| (size
= sec
->rawsize
) == 0)
4166 pe
= pe_data (abfd
);
4170 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4172 data
= bfd_malloc (size
);
4178 if (! bfd_get_section_contents (abfd
, sec
, data
, 0, size
))
4181 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4182 their lengths. Note - we rely upon the fact that the linker script
4183 does *not* sort the input .rsrc sections, so that the order in the
4184 linkinfo list matches the order in the output .rsrc section.
4186 We need to know the lengths because each input .rsrc section has padding
4187 at the end of a variable amount. (It does not appear to be based upon
4188 the section alignment or the file alignment). We need to skip any
4189 padding bytes when parsing the input .rsrc sections. */
4190 rsrc_sizes
= bfd_malloc (max_num_input_rsrc
* sizeof * rsrc_sizes
);
4191 if (rsrc_sizes
== NULL
)
4194 for (input
= pfinfo
->info
->input_bfds
;
4196 input
= input
->link
.next
)
4198 asection
* rsrc_sec
= bfd_get_section_by_name (input
, ".rsrc");
4200 /* PR 18372 - skip discarded .rsrc sections. */
4201 if (rsrc_sec
!= NULL
&& !discarded_section (rsrc_sec
))
4203 if (num_input_rsrc
== max_num_input_rsrc
)
4205 max_num_input_rsrc
+= 10;
4206 rsrc_sizes
= bfd_realloc (rsrc_sizes
, max_num_input_rsrc
4207 * sizeof * rsrc_sizes
);
4208 if (rsrc_sizes
== NULL
)
4212 BFD_ASSERT (rsrc_sec
->size
> 0);
4213 rsrc_sizes
[num_input_rsrc
++] = rsrc_sec
->size
;
4217 if (num_input_rsrc
< 2)
4220 /* Step one: Walk the section, computing the size of the tables,
4221 leaves and data and decide if we need to do anything. */
4222 dataend
= data
+ size
;
4223 num_resource_sets
= 0;
4225 while (data
< dataend
)
4227 bfd_byte
* p
= data
;
4229 data
= rsrc_count_directory (abfd
, data
, data
, dataend
, rva_bias
);
4233 /* Corrupted .rsrc section - cannot merge. */
4234 _bfd_error_handler (_("%pB: .rsrc merge failure: corrupt .rsrc section"),
4236 bfd_set_error (bfd_error_file_truncated
);
4240 if ((data
- p
) > rsrc_sizes
[num_resource_sets
])
4242 _bfd_error_handler (_("%pB: .rsrc merge failure: unexpected .rsrc size"),
4244 bfd_set_error (bfd_error_file_truncated
);
4247 /* FIXME: Should we add a check for "data - p" being much smaller
4248 than rsrc_sizes[num_resource_sets] ? */
4250 data
= p
+ rsrc_sizes
[num_resource_sets
];
4251 rva_bias
+= data
- p
;
4252 ++ num_resource_sets
;
4254 BFD_ASSERT (num_resource_sets
== num_input_rsrc
);
4256 /* Step two: Walk the data again, building trees of the resources. */
4258 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4260 type_tables
= bfd_malloc (num_resource_sets
* sizeof * type_tables
);
4261 if (type_tables
== NULL
)
4265 while (data
< dataend
)
4267 bfd_byte
* p
= data
;
4269 (void) rsrc_parse_directory (abfd
, type_tables
+ indx
, data
, data
,
4270 dataend
, rva_bias
, NULL
);
4271 data
= p
+ rsrc_sizes
[indx
];
4272 rva_bias
+= data
- p
;
4275 BFD_ASSERT (indx
== num_resource_sets
);
4277 /* Step three: Merge the top level tables (there can be only one).
4279 We must ensure that the merged entries are in ascending order.
4281 We also thread the top level table entries from the old tree onto
4282 the new table, so that they can be pulled off later. */
4284 /* FIXME: Should we verify that all type tables are the same ? */
4285 new_table
.characteristics
= type_tables
[0].characteristics
;
4286 new_table
.time
= type_tables
[0].time
;
4287 new_table
.major
= type_tables
[0].major
;
4288 new_table
.minor
= type_tables
[0].minor
;
4290 /* Chain the NAME entries onto the table. */
4291 new_table
.names
.first_entry
= NULL
;
4292 new_table
.names
.last_entry
= NULL
;
4294 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4295 rsrc_attach_chain (& new_table
.names
, & type_tables
[indx
].names
);
4297 rsrc_sort_entries (& new_table
.names
, TRUE
, & new_table
);
4299 /* Chain the ID entries onto the table. */
4300 new_table
.ids
.first_entry
= NULL
;
4301 new_table
.ids
.last_entry
= NULL
;
4303 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4304 rsrc_attach_chain (& new_table
.ids
, & type_tables
[indx
].ids
);
4306 rsrc_sort_entries (& new_table
.ids
, FALSE
, & new_table
);
4308 /* Step four: Create new contents for the .rsrc section. */
4309 /* Step four point one: Compute the size of each region of the .rsrc section.
4310 We do this now, rather than earlier, as the merging above may have dropped
4312 sizeof_leaves
= sizeof_strings
= sizeof_tables_and_entries
= 0;
4313 rsrc_compute_region_sizes (& new_table
);
4314 /* We increment sizeof_strings to make sure that resource data
4315 starts on an 8-byte boundary. FIXME: Is this correct ? */
4316 sizeof_strings
= (sizeof_strings
+ 7) & ~ 7;
4318 new_data
= bfd_zalloc (abfd
, size
);
4319 if (new_data
== NULL
)
4322 write_data
.abfd
= abfd
;
4323 write_data
.datastart
= new_data
;
4324 write_data
.next_table
= new_data
;
4325 write_data
.next_leaf
= new_data
+ sizeof_tables_and_entries
;
4326 write_data
.next_string
= write_data
.next_leaf
+ sizeof_leaves
;
4327 write_data
.next_data
= write_data
.next_string
+ sizeof_strings
;
4328 write_data
.rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4330 rsrc_write_directory (& write_data
, & new_table
);
4332 /* Step five: Replace the old contents with the new.
4333 We don't recompute the size as it's too late here to shrink section.
4334 See PR ld/20193 for more details. */
4335 bfd_set_section_contents (pfinfo
->output_bfd
, sec
, new_data
, 0, size
);
4336 sec
->size
= sec
->rawsize
= size
;
4339 /* Step six: Free all the memory that we have used. */
4340 /* FIXME: Free the resource tree, if we have one. */
4345 /* Handle the .idata section and other things that need symbol table
4349 _bfd_XXi_final_link_postscript (bfd
* abfd
, struct coff_final_link_info
*pfinfo
)
4351 struct coff_link_hash_entry
*h1
;
4352 struct bfd_link_info
*info
= pfinfo
->info
;
4353 bfd_boolean result
= TRUE
;
4355 /* There are a few fields that need to be filled in now while we
4356 have symbol table access.
4358 The .idata subsections aren't directly available as sections, but
4359 they are in the symbol table, so get them from there. */
4361 /* The import directory. This is the address of .idata$2, with size
4362 of .idata$2 + .idata$3. */
4363 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4364 ".idata$2", FALSE
, FALSE
, TRUE
);
4367 /* PR ld/2729: We cannot rely upon all the output sections having been
4368 created properly, so check before referencing them. Issue a warning
4369 message for any sections tht could not be found. */
4370 if ((h1
->root
.type
== bfd_link_hash_defined
4371 || h1
->root
.type
== bfd_link_hash_defweak
)
4372 && h1
->root
.u
.def
.section
!= NULL
4373 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4374 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
=
4375 (h1
->root
.u
.def
.value
4376 + h1
->root
.u
.def
.section
->output_section
->vma
4377 + h1
->root
.u
.def
.section
->output_offset
);
4381 (_("%pB: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4386 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4387 ".idata$4", FALSE
, FALSE
, TRUE
);
4389 && (h1
->root
.type
== bfd_link_hash_defined
4390 || h1
->root
.type
== bfd_link_hash_defweak
)
4391 && h1
->root
.u
.def
.section
!= NULL
4392 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4393 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].Size
=
4394 ((h1
->root
.u
.def
.value
4395 + h1
->root
.u
.def
.section
->output_section
->vma
4396 + h1
->root
.u
.def
.section
->output_offset
)
4397 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
);
4401 (_("%pB: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4406 /* The import address table. This is the size/address of
4408 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4409 ".idata$5", FALSE
, FALSE
, TRUE
);
4411 && (h1
->root
.type
== bfd_link_hash_defined
4412 || h1
->root
.type
== bfd_link_hash_defweak
)
4413 && h1
->root
.u
.def
.section
!= NULL
4414 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4415 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4416 (h1
->root
.u
.def
.value
4417 + h1
->root
.u
.def
.section
->output_section
->vma
4418 + h1
->root
.u
.def
.section
->output_offset
);
4422 (_("%pB: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4427 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4428 ".idata$6", FALSE
, FALSE
, TRUE
);
4430 && (h1
->root
.type
== bfd_link_hash_defined
4431 || h1
->root
.type
== bfd_link_hash_defweak
)
4432 && h1
->root
.u
.def
.section
!= NULL
4433 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4434 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4435 ((h1
->root
.u
.def
.value
4436 + h1
->root
.u
.def
.section
->output_section
->vma
4437 + h1
->root
.u
.def
.section
->output_offset
)
4438 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
);
4442 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4449 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4450 "__IAT_start__", FALSE
, FALSE
, TRUE
);
4452 && (h1
->root
.type
== bfd_link_hash_defined
4453 || h1
->root
.type
== bfd_link_hash_defweak
)
4454 && h1
->root
.u
.def
.section
!= NULL
4455 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4460 (h1
->root
.u
.def
.value
4461 + h1
->root
.u
.def
.section
->output_section
->vma
4462 + h1
->root
.u
.def
.section
->output_offset
);
4464 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4465 "__IAT_end__", FALSE
, FALSE
, TRUE
);
4467 && (h1
->root
.type
== bfd_link_hash_defined
4468 || h1
->root
.type
== bfd_link_hash_defweak
)
4469 && h1
->root
.u
.def
.section
!= NULL
4470 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4472 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4473 ((h1
->root
.u
.def
.value
4474 + h1
->root
.u
.def
.section
->output_section
->vma
4475 + h1
->root
.u
.def
.section
->output_offset
)
4477 if (pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
!= 0)
4478 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4479 iat_va
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
4484 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4485 " because .idata$6 is missing"), abfd
);
4491 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4492 (bfd_get_symbol_leading_char (abfd
) != 0
4493 ? "__tls_used" : "_tls_used"),
4494 FALSE
, FALSE
, TRUE
);
4497 if ((h1
->root
.type
== bfd_link_hash_defined
4498 || h1
->root
.type
== bfd_link_hash_defweak
)
4499 && h1
->root
.u
.def
.section
!= NULL
4500 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4501 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].VirtualAddress
=
4502 (h1
->root
.u
.def
.value
4503 + h1
->root
.u
.def
.section
->output_section
->vma
4504 + h1
->root
.u
.def
.section
->output_offset
4505 - pe_data (abfd
)->pe_opthdr
.ImageBase
);
4509 (_("%pB: unable to fill in DataDictionary[9] because __tls_used is missing"),
4513 /* According to PECOFF sepcifications by Microsoft version 8.2
4514 the TLS data directory consists of 4 pointers, followed
4515 by two 4-byte integer. This implies that the total size
4516 is different for 32-bit and 64-bit executables. */
4517 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4518 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x18;
4520 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x28;
4524 /* If there is a .pdata section and we have linked pdata finally, we
4525 need to sort the entries ascending. */
4526 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4528 asection
*sec
= bfd_get_section_by_name (abfd
, ".pdata");
4532 bfd_size_type x
= sec
->rawsize
;
4533 bfd_byte
*tmp_data
= NULL
;
4536 tmp_data
= bfd_malloc (x
);
4538 if (tmp_data
!= NULL
)
4540 if (bfd_get_section_contents (abfd
, sec
, tmp_data
, 0, x
))
4544 12, sort_x64_pdata
);
4545 bfd_set_section_contents (pfinfo
->output_bfd
, sec
,
4556 rsrc_process_section (abfd
, pfinfo
);
4558 /* If we couldn't find idata$2, we either have an excessively
4559 trivial program or are in DEEP trouble; we have to assume trivial